diff options
Diffstat (limited to 'veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java')
| -rw-r--r-- | veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java | 3071 |
1 files changed, 2923 insertions, 148 deletions
diff --git a/veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java b/veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java index 669a6ca..52bed2e 100644 --- a/veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java +++ b/veslibrary/ves_javalibrary/evel_javalib2/src/main/java/evel_javalibrary/att/com/EvelScalingMeasurement.java @@ -22,8 +22,13 @@ package evel_javalibrary.att.com; * limitations under the License.
*****************************************************************************/
+import java.awt.im.spi.InputMethod;
import java.text.MessageFormat;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
import javax.json.Json;
import javax.json.JsonArrayBuilder;
@@ -33,12 +38,90 @@ import javax.json.JsonObjectBuilder; import org.apache.log4j.Logger;
import org.slf4j.helpers.MessageFormatter;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIHSBP;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMINIC;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIbaseboardTemperature;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIbaseboardvoltageResulator;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIbattery;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIfan;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIglobalAggregateTemperatureMargin;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.IPMIpowerSupply;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.MEASUREMENT_IPMI_PROCESSOR;
+import evel_javalibrary.att.com.EvelScalingMeasurement.MEASUREMENT_IPMI.MEASUREMENT_IPMI_PROCESSOR.Processor_DIMMaggregate_Thermal_Margin;
+
public class EvelScalingMeasurement extends EvelHeader {
- int major_version = 2;
+ int major_version = 4;
int minor_version = 0;
+ /*
+ * VES6.0 Added Fields 14/07/2018
+ */
+
+
+
+ /*****************************************************************************
+ * MachineCheck Exception
+ * JSON equivalent field: machineCheckException
+ ******************************************************************************/
+ public class MACHINE_CHECK_EXCEPTION{
+ /**
+ *
+ */
+ // private static final long serialVersionUID = 1L;
+ String processIdentifier;
+ EvelOptionDouble correctedMemoryErrors;
+ EvelOptionDouble correctedMemoryErrors_In1Hr;
+ EvelOptionDouble uncorrectedMemoryErrors;
+ EvelOptionDouble uncorrectedMemoryErrors_In1Hr;
+
+
+ }
+
+ /**************************************************************************//**
+ * Huge Pages.
+ * JSON equivalent field: hugePages
+ *****************************************************************************/
+ public class MEASUREMENT_HUGE_PAGE {
+ String hugePagesIdentifier;
+ double bytesUsed;
+ public EvelOptionDouble bytesFree;
+ public EvelOptionDouble vmPageNumberUsed;
+ public EvelOptionDouble vmPageNumberFree;
+ public EvelOptionDouble percentUsed;
+ public EvelOptionDouble percentFree;
+
+ }
+
+ /**************************************************************************//**
+ * Process Stats.
+ * JSON equivalent field: processStats
+ *****************************************************************************/
+ public class MEASUREMENT_PROCESS_STATS {
+ String processIdentifier;
+ public EvelOptionDouble forkRate;
+ public EvelOptionDouble psStateBlocked;
+ public EvelOptionDouble psStatePaging;
+ public EvelOptionDouble psStateRunning;
+ public EvelOptionDouble psStateSleeping;
+ public EvelOptionDouble psStateStopped;
+ public EvelOptionDouble psStateZombie;
+
+ }
+
+ /**************************************************************************//**
+ * Load.
+ * JSON equivalent field: load
+ *****************************************************************************/
+ public class MEASUREMENT_LOAD {
+// String loadIdentifier;
+ public EvelOptionDouble shortTerm;
+ public EvelOptionDouble midTerm;
+ public EvelOptionDouble longTerm;
+
+ }
+
/**************************************************************************//**
* CPU Usage.
* JSON equivalent field: cpuUsage
@@ -54,6 +137,16 @@ public class EvelScalingMeasurement extends EvelHeader { public EvelOptionDouble sys;
public EvelOptionDouble user;
public EvelOptionDouble wait;
+ /*
+ * Ves6.0 added fields 14/07/2018
+ */
+ private EvelOptionDouble cpuCapacityContention;
+ public EvelOptionDouble cpuDemandAvg;
+ public EvelOptionDouble cpuDemandMhz;
+ public EvelOptionDouble cpuDemandPct;
+ public EvelOptionDouble cpuLatencyAvg;
+ public EvelOptionDouble cpuOverheadAvg;
+ public EvelOptionDouble cpuSwapWaitTime;
}
@@ -103,7 +196,26 @@ public class EvelScalingMeasurement extends EvelHeader { public EvelOptionDouble timewritelast;
public EvelOptionDouble timewritemax;
public EvelOptionDouble timewritemin;
-
+ /*
+ * VES6.0 Added fields 14/07/2018
+ */
+ public EvelOptionDouble diskBusResets;
+ public EvelOptionDouble diskCommandsAborted;
+ public EvelOptionDouble diskTime;
+ public EvelOptionDouble diskFlushRequests;
+ public EvelOptionDouble diskFlushTime;
+ public EvelOptionDouble diskCommandsAvg;
+ public EvelOptionDouble diskReadCommandsAvg;
+ public EvelOptionDouble diskWriteCommandsAvg;
+ public EvelOptionDouble diskTotalReadLatencyAvg;
+ public EvelOptionDouble diskTotalWriteLatencyAvg;
+
+ public EvelOptionDouble diskWeightedIoTimeAvg;
+ public EvelOptionDouble diskWeightedIoTimeLast;
+ public EvelOptionDouble diskWeightedIoTimeMax;
+ public EvelOptionDouble diskWeightedIoTimeMin;
+
+
}
/**************************************************************************//**
@@ -134,6 +246,19 @@ public class EvelScalingMeasurement extends EvelHeader { public EvelOptionDouble slabrecl;
public EvelOptionDouble slabunrecl;
public EvelOptionDouble memused;
+
+
+ /*
+ * VES6.0 Added fields 14/07/2018
+ */
+ public EvelOptionDouble memoryDemand;
+ public EvelOptionDouble memoryLatencyAvg;
+ public EvelOptionDouble memorySwapUsedAvg;
+ public EvelOptionDouble memorySwapOutAvg;
+ public EvelOptionDouble memorySwapInAvg;
+ public EvelOptionDouble memorySwapInRateAvg;
+ public EvelOptionDouble memorySwapOutRateAvg;
+ public EvelOptionDouble memorySharedAvg;
}
/**************************************************************************//**
@@ -166,7 +291,7 @@ public class EvelScalingMeasurement extends EvelHeader { * Virtual NIC usage.
* JSON equivalent field: vNicUsage
*****************************************************************************/
- public class MEASUREMENT_VNIC_PERFORMANCE {
+ public class MEASUREMENT_NIC_PERFORMANCE {
String vnic_id;
String valuesaresuspect;
/***************************************************************************/
@@ -242,6 +367,23 @@ public class EvelScalingMeasurement extends EvelHeader { public EvelOptionDouble tx_ucast_packets_acc;
/*Count of transmit unicast packets within the measurement interval*/
public EvelOptionDouble tx_ucast_packets_delta;
+
+ /*VES6.0 added field 14July*/
+ String nicIdentifier;
+
+ /*
+ * VES6.0 added field 19July
+ */
+ public EvelOptionDouble administrativeState;
+ public EvelOptionDouble operationalState;
+ public EvelOptionDouble receivedPercentDiscard;
+ public EvelOptionDouble receivedPercentError;
+ public EvelOptionDouble receivedUtilization;
+ public EvelOptionString speed;
+ public EvelOptionDouble transmittedPercentDiscard;
+ public EvelOptionDouble transmittedPercentError;
+ public EvelOptionDouble transmittedUtilization;
+
}
/**************************************************************************//**
@@ -280,6 +422,877 @@ public class EvelScalingMeasurement extends EvelHeader { String name;
ArrayList<CUSTOM_MEASUREMENT> measurements;
}
+
+
+
+
+
+
+
+ /*
+ * VES6.0 added fields 14July
+ */
+
+ /**************************************************************************//**
+ * IPMI.
+ * JSON equivalent field: Ipmi
+ *****************************************************************************/
+ public class MEASUREMENT_IPMI {
+
+ /***************************************************************************/
+ /* Optional fields */
+ /***************************************************************************/
+ public EvelOptionDouble exitAirTemperature;
+ public EvelOptionDouble ioModuleTemperature;
+ public EvelOptionDouble frontPanelTemperature;
+ public EvelOptionDouble systemAirflow;
+
+ ArrayList<MEASUREMENT_IPMI_PROCESSOR> ipmiprocessor;
+
+ public class MEASUREMENT_IPMI_PROCESSOR {
+ public String processorIdentifier;
+ public EvelOptionDouble processorThermalControlPercent;
+ public EvelOptionDouble processorDTSthermalMargin;
+
+ ArrayList<Processor_DIMMaggregate_Thermal_Margin> processorDIMMaggregateThermalMargin;
+
+ public class Processor_DIMMaggregate_Thermal_Margin {
+ public String processorDIMMaggregateThermalMarginIdentifier;
+ public double processorDIMMaggregateThermalMargin;
+
+
+ }
+
+ public void evel_measurement_IPMI_ProcessorDIMMaggregateThermalMargin_add(
+ String thermalMarginIdentifier,
+ double thermalMargin)
+ {
+ Processor_DIMMaggregate_Thermal_Margin pp = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(thermalMarginIdentifier != null);
+ assert(thermalMargin > 0.0);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding ThermalMarginIdentifier={0} Use={1}", thermalMarginIdentifier, thermalMargin));
+ pp = new Processor_DIMMaggregate_Thermal_Margin();
+ assert(pp != null);
+ pp.processorDIMMaggregateThermalMarginIdentifier = thermalMarginIdentifier;
+ assert(pp.processorDIMMaggregateThermalMargin >= 0.0);
+ pp.processorDIMMaggregateThermalMargin = thermalMargin;
+
+ if( processorDIMMaggregateThermalMargin == null ){
+ processorDIMMaggregateThermalMargin = new ArrayList<Processor_DIMMaggregate_Thermal_Margin>();
+ LOGGER.debug("Allocate new ProcessorDIMMaggregateThermalMargin");
+ }
+
+ processorDIMMaggregateThermalMargin.add(pp);
+
+ EVEL_EXIT();
+ }
+
+
+ }
+ public void evel_measurement_IPMI_MEASUREMENT_IPMI_PROCESSOR_add(
+ String processorIdentifier
+ )
+ {
+ MEASUREMENT_IPMI_PROCESSOR mIP = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(processorIdentifier != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", processorIdentifier));
+ mIP = new MEASUREMENT_IPMI_PROCESSOR();
+ assert(mIP != null);
+ mIP.processorIdentifier = processorIdentifier;
+ mIP.processorThermalControlPercent = new EvelOptionDouble();
+ mIP.processorDTSthermalMargin = new EvelOptionDouble();
+
+
+
+ if( ipmiprocessor == null ){
+ ipmiprocessor = new ArrayList<MEASUREMENT_IPMI_PROCESSOR>();
+ LOGGER.debug("Allocate new IPMI_PROCESSOR");
+ }
+
+ ipmiprocessor.add(mIP);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+
+
+ ArrayList<IPMIglobalAggregateTemperatureMargin> ipmiglobalAggregateTemperatureMarginArray;
+
+ public class IPMIglobalAggregateTemperatureMargin {
+ public String globalAggregateTemperatureMarginIdentifier;
+ public EvelOptionDouble globalAggregateTemeratureMargin;
+ }
+
+ public void evel_measurement_IPMI_MEASUREMENT_IPMIglobalAggregateTemperatureMargin_add(
+ String globalAggregateTemperatureMarginIdentifier
+ )
+ {
+ IPMIglobalAggregateTemperatureMargin ipmiGlobalAgg = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(globalAggregateTemperatureMarginIdentifier != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", globalAggregateTemperatureMarginIdentifier));
+ ipmiGlobalAgg = new IPMIglobalAggregateTemperatureMargin();
+ assert(ipmiGlobalAgg != null);
+ ipmiGlobalAgg.globalAggregateTemperatureMarginIdentifier = globalAggregateTemperatureMarginIdentifier;
+ ipmiGlobalAgg.globalAggregateTemeratureMargin = new EvelOptionDouble();
+
+
+ if( ipmiglobalAggregateTemperatureMarginArray == null ){
+ ipmiglobalAggregateTemperatureMarginArray = new ArrayList<IPMIglobalAggregateTemperatureMargin>();
+ LOGGER.debug("Allocate new IPMIglobalAggregateTemperatureMargin");
+ }
+
+ ipmiglobalAggregateTemperatureMarginArray.add(ipmiGlobalAgg);
+
+ EVEL_EXIT();
+ }
+
+
+
+ ArrayList<IPMIpowerSupply> ipmipowerSupply;
+
+ public class IPMIpowerSupply {
+ public String powerSupplyIdentifier;
+ public EvelOptionDouble powerSupplyInputPower;
+ public EvelOptionDouble powerSupplycurrentOutputPercent;
+ public EvelOptionDouble powerSupplyTemperature;
+ }
+
+ public void evel_measurement_IPMI_MEASUREMENT_IPMIpowerSupply_add(
+ String powerSupplyIdentifier
+ )
+ {
+ IPMIpowerSupply ipmipower = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmipower != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", powerSupplyIdentifier));
+ ipmipower = new IPMIpowerSupply();
+ assert(ipmipower != null);
+ ipmipower.powerSupplyIdentifier = powerSupplyIdentifier;
+ ipmipower.powerSupplycurrentOutputPercent = new EvelOptionDouble();
+ ipmipower.powerSupplyInputPower = new EvelOptionDouble();
+ ipmipower.powerSupplyTemperature = new EvelOptionDouble();
+
+
+ if( ipmipowerSupply == null ){
+ ipmipowerSupply = new ArrayList<IPMIpowerSupply>();
+ LOGGER.debug("Allocate new IPMIpowerSupply");
+ }
+
+ ipmipowerSupply.add(ipmipower);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+
+ ArrayList<IPMIbattery> ipmibattery;
+
+ public class IPMIbattery {
+ public String batteryIdentifier;
+ public EvelOptionString batteryType;
+ public EvelOptionDouble batteryVoltageLevel;
+
+ }
+
+ public void evel_measurement_IPMI_MEASUREMENT_IPMIbattery_add(
+ String batteryIdentifier
+ )
+ {
+ IPMIbattery imibatt = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(imibatt != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", batteryIdentifier));
+ imibatt = new IPMIbattery();
+ assert(imibatt != null);
+ imibatt.batteryIdentifier = batteryIdentifier;
+ imibatt.batteryType = new EvelOptionString();
+ imibatt.batteryVoltageLevel = new EvelOptionDouble();
+
+ if( ipmibattery == null ){
+ ipmibattery = new ArrayList<IPMIbattery>();
+ LOGGER.debug("Allocate new IPMIbattery");
+ }
+
+ ipmibattery.add(imibatt);
+
+ EVEL_EXIT();
+ }
+
+
+
+ ArrayList<IPMINIC> ipmiNIC;
+
+ public class IPMINIC {
+ public String nic_Identifier;
+ public EvelOptionDouble nic_Temperature;
+
+
+ }
+
+ public void evel_measurement_IPMINIC_add(
+ String nic_Identifier
+ )
+ {
+ IPMINIC ipmiNic = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmiNic != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", nic_Identifier));
+ ipmiNic = new IPMINIC();
+ assert(ipmiNic != null);
+ ipmiNic.nic_Identifier = nic_Identifier;
+ ipmiNic.nic_Temperature = new EvelOptionDouble();
+
+
+
+ if( ipmiNIC == null ){
+ ipmiNIC = new ArrayList<IPMINIC>();
+ LOGGER.debug("Allocate new IPMINIC");
+ }
+
+ ipmiNIC.add(ipmiNic);
+
+ EVEL_EXIT();
+ }
+
+
+
+ ArrayList<IPMIHSBP> ipmiHSBP;
+
+ public class IPMIHSBP {
+ public String hsbpIdentifier;
+ public EvelOptionDouble hsbpTemperature;
+
+
+ }
+
+
+ public void evel_measurement_IPMIHSBP_add(
+ String hsbpIdentifier
+ )
+ {
+ IPMIHSBP ipmiHsbp = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmiHsbp != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", hsbpIdentifier));
+ ipmiHsbp = new IPMIHSBP();
+ assert(ipmiHsbp != null);
+ ipmiHsbp.hsbpIdentifier = hsbpIdentifier;
+ ipmiHsbp.hsbpTemperature = new EvelOptionDouble();
+
+
+ if( ipmiHSBP == null ){
+ ipmiHSBP = new ArrayList<IPMIHSBP>();
+ LOGGER.debug("Allocate new IPMIHSBP");
+ }
+
+ ipmiHSBP.add(ipmiHsbp);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+ ArrayList<IPMIbaseboardTemperature> ipmibaseboardTemperature;
+
+ public class IPMIbaseboardTemperature {
+ public String baseboardTemperatureIdentifier;
+ public EvelOptionDouble baseboardTemperature;
+
+
+ }
+
+
+
+ public void evel_measurement_IPMIbaseboardTemperature_add(
+ String baseboardTemperatureIdentifier
+ )
+ {
+ IPMIbaseboardTemperature ipmibaseboardTemp = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmibaseboardTemperature != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", baseboardTemperatureIdentifier));
+ ipmibaseboardTemp = new IPMIbaseboardTemperature();
+ assert(ipmibaseboardTemp != null);
+ ipmibaseboardTemp.baseboardTemperatureIdentifier = baseboardTemperatureIdentifier;
+ ipmibaseboardTemp.baseboardTemperature = new EvelOptionDouble();
+
+ if( ipmibaseboardTemperature == null ){
+ ipmibaseboardTemperature = new ArrayList<IPMIbaseboardTemperature>();
+ LOGGER.debug("Allocate new IPMIbaseboardTemperature");
+ }
+
+ ipmibaseboardTemperature.add(ipmibaseboardTemp);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+ ArrayList<IPMIbaseboardvoltageResulator> ipmiBaseboardvoltageResulator;
+
+ public class IPMIbaseboardvoltageResulator {
+ public String baseboardVoltageRegulatorIdentifier;
+ public EvelOptionDouble voltageRegulatorTemperature;
+
+
+ }
+
+
+ public void evel_measurement_IPMIbaseboardvoltageResulator_add(
+ String baseboardVoltageRegulatorIdentifier
+ )
+ {
+ IPMIbaseboardvoltageResulator ipmiBaseboardvoltageRes = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmiBaseboardvoltageRes != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", baseboardVoltageRegulatorIdentifier));
+ ipmiBaseboardvoltageRes = new IPMIbaseboardvoltageResulator();
+ assert(ipmiBaseboardvoltageRes != null);
+ ipmiBaseboardvoltageRes.baseboardVoltageRegulatorIdentifier = baseboardVoltageRegulatorIdentifier;
+ ipmiBaseboardvoltageRes.voltageRegulatorTemperature = new EvelOptionDouble();
+
+ if( ipmiBaseboardvoltageResulator == null ){
+ ipmiBaseboardvoltageResulator = new ArrayList<IPMIbaseboardvoltageResulator>();
+ LOGGER.debug("Allocate new IPMIbaseboardvoltageResulator");
+ }
+
+ ipmiBaseboardvoltageResulator.add(ipmiBaseboardvoltageRes);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+ ArrayList<IPMIfan> ipmiFan;
+
+ public class IPMIfan {
+ public String fanIdentifier;
+ public EvelOptionDouble fanSpeed;
+
+
+ }
+
+ public void evel_measurement_IPMIfan_add(
+ String fanIdentifier
+ )
+ {
+ IPMIfan ipmiF = null;
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmiF != null);
+
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding Identifier={0}", fanIdentifier));
+ ipmiF = new IPMIfan();
+ assert(ipmiF != null);
+ ipmiF.fanIdentifier = fanIdentifier;
+ ipmiF.fanSpeed = new EvelOptionDouble();
+
+ if( ipmiFan == null ){
+ ipmiFan = new ArrayList<IPMIfan>();
+ LOGGER.debug("Allocate new IPMIfan");
+ }
+
+ ipmiFan.add(ipmiF);
+
+ EVEL_EXIT();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// ArrayList<MEASUREMENT_IPMI_PERCENT_USAGE> ipmi_percentage;
+// ArrayList<MEASUREMENT_IPMI_VOLTAGE> ipmi_voltage;
+//
+// ArrayList<MEASUREMENT_IPMI_TEMPARATURE> ipmi_temparature;
+// ArrayList<MEASUREMENT_IPMI_FAN> ipmi_fan;
+// ArrayList<MEASUREMENT_IPMI_CFM> ipmi_cfm;
+// ArrayList<MEASUREMENT_IPMI_WATTS> ipmi_watts;
+// /**************************************************************************//**
+// * IPMI Percent Usage.
+// * JSON equivalent field: PercentUsage
+// *****************************************************************************/
+// public class MEASUREMENT_IPMI_PERCENT_USAGE {
+// public EvelOptionDouble P2ThermCtrl;
+// public EvelOptionDouble P1ThermCtrl;
+// public EvelOptionDouble PS1CurrOut;
+//
+// }
+//
+// public class MEASUREMENT_IPMI_VOLTAGE {
+// public EvelOptionDouble BB3_3vVbat;
+// public EvelOptionDouble BB12_0v;
+//
+// }
+//
+// public class MEASUREMENT_IPMI_TEMPARATURE {
+// public EvelOptionDouble AggThermMgn1;
+// public EvelOptionDouble DIMMThrmMrgn4;
+// public EvelOptionDouble DIMMThrmMrgn3;
+// public EvelOptionDouble DIMMThrmMrgn2;
+// public EvelOptionDouble DIMMThrmMrgn1;
+// public EvelOptionDouble P2DTSThermMgn;
+// public EvelOptionDouble P1DTSThermMgn;
+// public EvelOptionDouble P2ThermCtrl;
+// public EvelOptionDouble P1ThermCtrl;
+// public EvelOptionDouble P2ThermMargin;
+// public EvelOptionDouble P1ThermMargin;
+// public EvelOptionDouble PS1Temperature;
+// public EvelOptionDouble LANNICTemp;
+// public EvelOptionDouble ExitAirTemp;
+// public EvelOptionDouble HSBP1Temp;
+// public EvelOptionDouble IOModTemp;
+// public EvelOptionDouble BBLftRearTemp;
+// public EvelOptionDouble BBRtRearTemp;
+// public EvelOptionDouble BBBMCTemp;
+// public EvelOptionDouble SSBTemp;
+// public EvelOptionDouble FrontPanelTemp;
+// public EvelOptionDouble BBP2VRTemp;
+// public EvelOptionDouble BBP1VRTemp;
+//
+// }
+//
+// public class MEASUREMENT_IPMI_FAN {
+// public EvelOptionDouble SystemFan6B;
+// public EvelOptionDouble SystemFan6A;
+// public EvelOptionDouble SystemFan5B;
+// public EvelOptionDouble SystemFan5A;
+// public EvelOptionDouble SystemFan4B;
+// public EvelOptionDouble SystemFan4A;
+// public EvelOptionDouble SystemFan3B;
+// public EvelOptionDouble SystemFan3A;
+// public EvelOptionDouble SystemFan2B;
+// public EvelOptionDouble SystemFa_2A;
+// public EvelOptionDouble SystemFan1B;
+// public EvelOptionDouble SystemFan1A;
+//
+// }
+// public class MEASUREMENT_IPMI_CFM {
+// public EvelOptionDouble System_Airflow;
+//
+// }
+// public class MEASUREMENT_IPMI_WATTS {
+// public EvelOptionDouble PS1InputPower;
+//
+// }
+//
+//
+// public MEASUREMENT_IPMI_TEMPARATURE evel_measurement_new_temparature_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_TEMPARATURE temparature = new MEASUREMENT_IPMI_TEMPARATURE();
+// assert(temparature != null);
+// temparature.AggThermMgn1 = new EvelOptionDouble();
+// temparature.DIMMThrmMrgn4 = new EvelOptionDouble();
+//
+// temparature.DIMMThrmMrgn3 = new EvelOptionDouble();
+// temparature.DIMMThrmMrgn2 = new EvelOptionDouble();
+// temparature.DIMMThrmMrgn1 = new EvelOptionDouble();
+// temparature.P2DTSThermMgn = new EvelOptionDouble();
+// temparature.P1DTSThermMgn = new EvelOptionDouble();
+// temparature.P2ThermCtrl = new EvelOptionDouble();
+// temparature.P1ThermCtrl = new EvelOptionDouble();
+// temparature.P2ThermMargin = new EvelOptionDouble();
+// temparature.P1ThermMargin = new EvelOptionDouble();
+// temparature.PS1Temperature = new EvelOptionDouble();
+// temparature.LANNICTemp = new EvelOptionDouble();
+// temparature.ExitAirTemp = new EvelOptionDouble();
+// temparature.HSBP1Temp = new EvelOptionDouble();
+// temparature.IOModTemp = new EvelOptionDouble();
+// temparature.BBLftRearTemp = new EvelOptionDouble();
+// temparature.BBRtRearTemp = new EvelOptionDouble();
+// temparature.BBBMCTemp = new EvelOptionDouble();
+// temparature.SSBTemp = new EvelOptionDouble();
+// temparature.FrontPanelTemp = new EvelOptionDouble();
+// temparature.BBP2VRTemp = new EvelOptionDouble();
+// temparature.BBP1VRTemp = new EvelOptionDouble();
+//
+//
+//
+// if( ipmi_temparature == null ){
+// ipmi_temparature = new ArrayList<MEASUREMENT_IPMI_TEMPARATURE>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_temparature.add(temparature);
+//
+// EVEL_EXIT();
+// return temparature;
+// }
+//
+//
+//
+// public MEASUREMENT_IPMI_FAN evel_measurement_new_fan_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_FAN fan = new MEASUREMENT_IPMI_FAN();
+// assert(fan != null);
+// fan.SystemFan6B = new EvelOptionDouble();
+// fan.SystemFan6A = new EvelOptionDouble();
+// fan.SystemFan5B = new EvelOptionDouble();
+// fan.SystemFan5A = new EvelOptionDouble();
+// fan.SystemFan4B = new EvelOptionDouble();
+// fan.SystemFan4A = new EvelOptionDouble();
+// fan.SystemFan3B = new EvelOptionDouble();
+// fan.SystemFan3A = new EvelOptionDouble();
+// fan.SystemFan2B = new EvelOptionDouble();
+// fan.SystemFa_2A = new EvelOptionDouble();
+// fan.SystemFan1B = new EvelOptionDouble();
+// fan.SystemFan1A = new EvelOptionDouble();
+//
+// if( ipmi_fan == null ){
+// ipmi_fan = new ArrayList<MEASUREMENT_IPMI_FAN>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_fan.add(fan);
+//
+// EVEL_EXIT();
+// return fan;
+// }
+//
+//
+// public MEASUREMENT_IPMI_CFM evel_measurement_new_cfm_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_CFM cfm = new MEASUREMENT_IPMI_CFM();
+// assert(cfm != null);
+// cfm.System_Airflow = new EvelOptionDouble();
+//
+//
+//
+//
+//
+// if( ipmi_cfm == null ){
+// ipmi_cfm = new ArrayList<MEASUREMENT_IPMI_CFM>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_cfm.add(cfm);
+//
+// EVEL_EXIT();
+// return cfm;
+// }
+//
+//
+// public MEASUREMENT_IPMI_WATTS evel_measurement_new_watts_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_WATTS watts = new MEASUREMENT_IPMI_WATTS();
+// assert(watts != null);
+// watts.PS1InputPower = new EvelOptionDouble();
+//
+//
+//
+//
+//
+// if( ipmi_watts == null ){
+// ipmi_watts = new ArrayList<MEASUREMENT_IPMI_WATTS>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_watts.add(watts);
+//
+// EVEL_EXIT();
+// return watts;
+// }
+
+
+// public MEASUREMENT_IPMI_VOLTAGE evel_measurement_new_voltage_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_VOLTAGE voltage = new MEASUREMENT_IPMI_VOLTAGE();
+// assert(voltage != null);
+// voltage.BB12_0v = new EvelOptionDouble();
+// voltage.BB3_3vVbat = new EvelOptionDouble();
+//
+//
+//
+//
+// if( ipmi_voltage == null ){
+// ipmi_voltage = new ArrayList<MEASUREMENT_IPMI_VOLTAGE>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_voltage.add(voltage);
+//
+// EVEL_EXIT();
+// return voltage;
+// }
+
+// public MEASUREMENT_IPMI_PERCENT_USAGE evel_measurement_new_percent_usage_add(double usage)
+// {
+// EVEL_ENTER();
+//
+// /***************************************************************************/
+// /* Check assumptions. */
+// /***************************************************************************/
+// assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(usage >= 0.0);
+//
+// /***************************************************************************/
+// /* Allocate a container for the value and push onto the list. */
+// /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", usage));
+// MEASUREMENT_IPMI_PERCENT_USAGE percent_usage = new MEASUREMENT_IPMI_PERCENT_USAGE();
+// assert(percent_usage != null);
+// percent_usage.P1ThermCtrl = new EvelOptionDouble();
+// percent_usage.P2ThermCtrl = new EvelOptionDouble();
+// percent_usage.PS1CurrOut = new EvelOptionDouble();
+//
+//
+//
+// if( ipmi_percentage == null ){
+// ipmi_percentage = new ArrayList<MEASUREMENT_IPMI_PERCENT_USAGE>();
+// LOGGER.debug("Allocate percent_usage");
+// }
+//
+// ipmi_percentage.add(percent_usage);
+//
+// EVEL_EXIT();
+// return percent_usage;
+// }
+//
+}
+
+ public MEASUREMENT_IPMI evel_meas_ipmi_add(MEASUREMENT_IPMI ipmi)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(ipmi != null);
+
+ if( ipmis == null ){
+ ipmis = new ArrayList<MEASUREMENT_IPMI>();
+ LOGGER.debug("Allocate new file system usage");
+ }
+
+
+ ipmis.add(ipmi);
+
+ EVEL_EXIT();
+
+ return ipmi;
+ }
+
+ public void evel_measurement_ipmi_exitAirTemperature_set(MEASUREMENT_IPMI ipmi,
+ double val)
+ {
+ EVEL_ENTER();
+ ipmi.exitAirTemperature.SetValuePr(val,"System fan exit air flow temperature in Celsius ");
+ EVEL_EXIT();
+ }
+ public void evel_measurement_ipmi_frontPanelTemperature_set(MEASUREMENT_IPMI ipmi,
+ double val)
+ {
+ EVEL_ENTER();
+ ipmi.frontPanelTemperature.SetValuePr(val,"Front panel temp in Celsius");
+ EVEL_EXIT();
+ }
+ public void evel_measurement_ipmi_ioModuleTemperature_set(MEASUREMENT_IPMI ipmi,
+ double val)
+ {
+ EVEL_ENTER();
+ ipmi.ioModuleTemperature.SetValuePr(val,"Io module temp in Celsius ");
+ EVEL_EXIT();
+ }
+ public void evel_measurement_ipmi_systemAirflow_set(MEASUREMENT_IPMI ipmi,
+ double val)
+ {
+ EVEL_ENTER();
+ ipmi.systemAirflow.SetValuePr(val,"Airflow in cubic feet per minute (cfm)");
+ EVEL_EXIT();
+ }
+
+
+
+
+
/***************************************************************************/
@@ -290,13 +1303,26 @@ public class EvelScalingMeasurement extends EvelHeader { /***************************************************************************/
/* Optional fields */
/***************************************************************************/
- ArrayList<String[]> additional_info;
+ // ArrayList<String[]> additional_info;
+
+ HashMap<String, String > additional_inf;
+
ArrayList<MEASUREMENT_GROUP> additional_measurements;
ArrayList<javax.json.JsonObject> additional_objects;
ArrayList<MEASUREMENT_CODEC_USE> codec_usage;
EvelOptionInt concurrent_sessions;
EvelOptionInt configured_entities;
ArrayList<MEASUREMENT_CPU_USE> cpu_usage;
+ //VES6.0 Added field 14/07/2018
+ ArrayList<MEASUREMENT_HUGE_PAGE> huge_pages;
+ ArrayList<MEASUREMENT_LOAD> loads;
+ ArrayList<MEASUREMENT_PROCESS_STATS> process_stats;
+ ArrayList<MEASUREMENT_IPMI> ipmis;
+ ArrayList<MACHINE_CHECK_EXCEPTION> machineCheckException;
+
+
+
+
ArrayList<MEASUREMENT_DISK_USE> disk_usage;
boolean errstat;
MEASUREMENT_ERRORS myerrors;
@@ -308,7 +1334,7 @@ public class EvelScalingMeasurement extends EvelHeader { EvelOptionInt media_ports_in_use;
EvelOptionInt request_rate;
EvelOptionInt vnfc_scaling_metric;
- ArrayList<MEASUREMENT_VNIC_PERFORMANCE> vnic_usage;
+ ArrayList<MEASUREMENT_NIC_PERFORMANCE> vnic_usage;
/***************************************************************************/
@@ -348,7 +1374,7 @@ public class EvelScalingMeasurement extends EvelHeader { event_domain = EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT;
//initialize optional fields
measurement_interval = meas_interval;
- additional_info = null;
+ additional_inf = null;
additional_measurements = null;
additional_objects = null;
cpu_usage = null;
@@ -361,6 +1387,14 @@ public class EvelScalingMeasurement extends EvelHeader { feature_usage = null;
errstat = false;
+
+ huge_pages=null;
+ loads = null;
+ process_stats=null;
+ ipmis=null;
+ machineCheckException = null;
+
+
mean_request_latency = new EvelOptionDouble(false, 0.0);
vnfc_scaling_metric = new EvelOptionInt(false, 0);
concurrent_sessions = new EvelOptionInt(false, 0);
@@ -413,7 +1447,7 @@ public class EvelScalingMeasurement extends EvelHeader { *****************************************************************************/
public void evel_measurement_addl_info_add(String name, String value)
{
- String[] addl_info = null;
+ // String[] addl_info = null;
EVEL_ENTER();
/***************************************************************************/
@@ -423,22 +1457,76 @@ public class EvelScalingMeasurement extends EvelHeader { assert(name != null);
assert(value != null);
- if( additional_info == null )
+ if( additional_inf == null )
{
- additional_info = new ArrayList<String[]>();
+ additional_inf = new HashMap<String, String >();
}
LOGGER.debug(MessageFormat.format("Adding name={0} value={1}", name, value));
- addl_info = new String[2];
- assert(addl_info != null);
- addl_info[0] = name;
- addl_info[1] = value;
-
- additional_info.add(addl_info);
+ // addl_info = new String[2];
+ // assert(addl_info != null);
+ // addl_info[0] = name;
+ // addl_info[1] = value;
+ additional_inf.put(name, value);
+ // additional_info.add(addl_info);
EVEL_EXIT();
}
+ /**************************************************************************/
+ /* IPMI. */
+ /* JSON equivalent field: Ipmi */
+ /*****************************************************************************/
+
+ public MEASUREMENT_IPMI evel_measurement_new_ipmis_add()
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ //LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", id, usage));
+ MEASUREMENT_IPMI ipmi = new MEASUREMENT_IPMI();
+ assert(ipmi != null);
+ //cpu_use.id = id;
+ //cpu_use.usage = usage;
+ ipmi.exitAirTemperature = new EvelOptionDouble();
+ ipmi.frontPanelTemperature = new EvelOptionDouble();
+ ipmi.ioModuleTemperature = new EvelOptionDouble();
+ ipmi.systemAirflow = new EvelOptionDouble();
+
+
+ if( ipmis == null ){
+ ipmis= new ArrayList<MEASUREMENT_IPMI>();
+ LOGGER.debug("Allocate new ipmis");
+ }
+
+ ipmis.add(ipmi);
+
+ EVEL_EXIT();
+ return ipmi;
+ }
+
+
+
+ /*
+ *
+ */
+
+
+
+
+
+
+
+
+
+
/**************************************************************************//**
* Set the Concurrent Sessions property of the Measurement.
*
@@ -601,8 +1689,556 @@ public class EvelScalingMeasurement extends EvelHeader { EVEL_EXIT();
}
+
+
+
+ /*
+ * VES6.0 Added fields 14July2018
+ */
+
+ /**************************************************************************//**
+ load average figures giving the number of jobs in the run queue (state R) or waiting for disk I/O (state D) averaged over 1 Minute
+ measured CPU and IO utilization for 1 min using /proc/loadavg
+ * The name and value are null delimited ASCII strings. The library takes
+ * a copy so the caller does not have to preserve values after the function
+ * returns.
+ *
+ *
+ * @param id ASCIIZ string with the CPU's identifier.
+ * @param usage CPU utilization.
+ *****************************************************************************/
+ public MEASUREMENT_PROCESS_STATS evel_measurement_new_process_stats_add(String id, double usage)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(id != null);
+ assert(usage >= 0.0);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", id, usage));
+ MEASUREMENT_PROCESS_STATS process_stat = new MEASUREMENT_PROCESS_STATS();
+ assert(process_stat != null);
+ process_stat.processIdentifier = id;
+ process_stat.forkRate = new EvelOptionDouble();
+ process_stat.psStateBlocked = new EvelOptionDouble();
+ process_stat.psStatePaging = new EvelOptionDouble();
+ process_stat.psStateRunning = new EvelOptionDouble();
+ process_stat.psStateSleeping = new EvelOptionDouble();
+ process_stat.psStateStopped = new EvelOptionDouble();
+ process_stat.psStateZombie = new EvelOptionDouble();
+
+
+ if( process_stats == null ){
+ process_stats = new ArrayList<MEASUREMENT_PROCESS_STATS>();
+ LOGGER.debug("Allocate Process_Stats");
+ }
+
+ process_stats.add(process_stat);
+
+ EVEL_EXIT();
+ return process_stat;
+ }
+
+
+
+
+
+
+ /**************************************************************************//**
+ * the number of threads created since the last reboo
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_forkRate_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.forkRate.SetValuePr(val,"the number of threads created since the last reboot");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * the number of processes in a blocked state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStateBlocked_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStateBlocked.SetValuePr(val,"the number of processes in a blocked state");
+ EVEL_EXIT();
+ }
+
+
+ /**************************************************************************//**
+ * the number of processes in a paging state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStatePaging_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStatePaging.SetValuePr(val,"the number of processes in a paging state");
+ EVEL_EXIT();
+ }
+
+
+
+ /**************************************************************************//**
+ * the number of processes in a running state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStateRunning_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStateRunning.SetValuePr(val,"the number of processes in a running state");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * the number of processes in a sleeping state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStateSleeping_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStateSleeping.SetValuePr(val,"the number of processes in a sleeping state");
+ EVEL_EXIT();
+ }
+
+
+ /**************************************************************************//**
+ * the number of processes in a stopped state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStateStopped_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStateStopped.SetValuePr(val,"the number of processes in a stopped state");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * the number of processes in a Zombie state
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_process_stats_psStateZombie_set(MEASUREMENT_PROCESS_STATS process_stat,
+ double val)
+ {
+ EVEL_ENTER();
+ process_stat.psStateZombie.SetValuePr(val,"the number of processes in a Zombie state");
+ EVEL_EXIT();
+ }
+
+ /*
+ * VES6.0 Added fields 14July2018
+ */
+
+ /**************************************************************************//**
+ load average figures giving the number of jobs in the run queue (state R) or waiting for disk I/O (state D) averaged over 1 Minute
+ measured CPU and IO utilization for 1 min using /proc/loadavg
+ * The name and value are null delimited ASCII strings. The library takes
+ * a copy so the caller does not have to preserve values after the function
+ * returns.
+ *
+ *
+ * @param usage CPU utilization.
+ *****************************************************************************/
+ public MEASUREMENT_LOAD evel_measurement_new_load_add(double usage)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+// assert(id != null);
+ assert(usage >= 0.0);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+// LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", id, usage));
+ MEASUREMENT_LOAD load = new MEASUREMENT_LOAD();
+ assert(load != null);
+// load.loadIdentifier = id;
+ load.shortTerm = new EvelOptionDouble();
+ load.midTerm = new EvelOptionDouble();
+ load.longTerm = new EvelOptionDouble();
+
+ if( loads == null ){
+ loads = new ArrayList<MEASUREMENT_LOAD>();
+ LOGGER.debug("Allocate Load");
+ }
+
+ loads.add(load);
+
+ EVEL_EXIT();
+ return load;
+ }
+
+ /**************************************************************************//**
+ * load average figures giving the number of jobs in the run queue (state R) or waiting for disk I/O (state D) averaged over 1 Minute
+ measured CPU and IO utilization for 1 min using /proc/loadavg"
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_load_shortTerm_set(MEASUREMENT_LOAD load,
+ double val)
+ {
+ EVEL_ENTER();
+ load.shortTerm.SetValuePr(val,"load short term");
+ EVEL_EXIT();
+ }
/**************************************************************************//**
+ * "load average figures giving the number of jobs in the run queue (state R) or waiting for disk I/O (state D) averaged over 5 Minutes
+ measured CPU and IO utilization for 5 mins using /proc/loadavg"
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_load_midTerm_set(MEASUREMENT_LOAD load,
+ double val)
+ {
+ EVEL_ENTER();
+ load.midTerm.SetValuePr(val,"load midterm");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * load average figures giving the number of jobs in the run queue (state R) or waiting for disk I/O (state D) averaged over 15 Minutes
+ measured CPU and IO utilization for 15 mins using /proc/loadavg
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_load_longTerm_set(MEASUREMENT_LOAD load,
+ double val)
+ {
+ EVEL_ENTER();
+ load.longTerm.SetValuePr(val,"load longterm");
+ EVEL_EXIT();
+ }
+
+ /******************************************************************************
+ *
+ *****************************************************************************/
+
+ public MACHINE_CHECK_EXCEPTION evel_measurement_new_machine_check_exception_add(String id)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(id != null);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding id={0}", id));
+ MACHINE_CHECK_EXCEPTION machine_check_exception = new MACHINE_CHECK_EXCEPTION();
+ assert(machine_check_exception != null);
+ machine_check_exception.processIdentifier = id;
+ machine_check_exception.correctedMemoryErrors = new EvelOptionDouble();
+ machine_check_exception.correctedMemoryErrors_In1Hr = new EvelOptionDouble();
+ machine_check_exception.uncorrectedMemoryErrors = new EvelOptionDouble();
+ machine_check_exception.uncorrectedMemoryErrors_In1Hr = new EvelOptionDouble();
+
+
+ if( machineCheckException == null ){
+ machineCheckException = new ArrayList<MACHINE_CHECK_EXCEPTION>();
+ LOGGER.debug("Allocate new machineCheckException");
+ }
+
+ machineCheckException.add(machine_check_exception);
+
+ EVEL_EXIT();
+ return machine_check_exception;
+ }
+
+
+ public MACHINE_CHECK_EXCEPTION evel_measurement_Exception_correctedMemoryErrors_set(MACHINE_CHECK_EXCEPTION exception,
+ double val)
+ {
+ EVEL_ENTER();
+ exception.correctedMemoryErrors.SetValuePr(val, "Exception_correctedMemoryErrors");
+ EVEL_EXIT();
+
+ return exception;
+ }
+
+ public MACHINE_CHECK_EXCEPTION evel_measurement_Exception_correctedMemoryErrors_In1Hr_set(MACHINE_CHECK_EXCEPTION exception,
+ double val)
+ {
+ EVEL_ENTER();
+ exception.correctedMemoryErrors_In1Hr.SetValuePr(val, "Exception_correctedMemoryErrors_In1Hr");
+ EVEL_EXIT();
+ return exception;
+
+ }
+
+ public MACHINE_CHECK_EXCEPTION evel_measurement_Exception_uncorrectedMemoryErrors_set(MACHINE_CHECK_EXCEPTION exception,
+ double val)
+ {
+ EVEL_ENTER();
+ exception.uncorrectedMemoryErrors.SetValuePr(val, "Exception_uncorrectedMemoryErrors");
+ EVEL_EXIT();
+ return exception;
+ }
+
+ public MACHINE_CHECK_EXCEPTION evel_measurement_Exception_uncorrectedMemoryErrors_In1Hr_set(MACHINE_CHECK_EXCEPTION exception,
+ double val)
+ {
+ EVEL_ENTER();
+ exception.uncorrectedMemoryErrors_In1Hr.SetValuePr(val, "Exception_uncorrectedMemoryErrors_In1Hr");
+ EVEL_EXIT();
+ return exception;
+ }
+
+
+ /*
+ * VES6.0 Added fields 14July2018
+ */
+ /**************************************************************************//**
+ * Add an additional HUGE PAGE value name/value pair to the Measurement.
+ *
+ * The name and value are null delimited ASCII strings. The library takes
+ * a copy so the caller does not have to preserve values after the function
+ * returns.
+ *
+ *
+ * @param id ASCIIZ string with the CPU's identifier.
+ * @param usage CPU utilization.
+ *****************************************************************************/
+ public MEASUREMENT_HUGE_PAGE evel_measurement_new_huge_page_add(String id, double usage)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check assumptions. */
+ /***************************************************************************/
+ assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
+ assert(id != null);
+ assert(usage >= 0.0);
+
+ /***************************************************************************/
+ /* Allocate a container for the value and push onto the list. */
+ /***************************************************************************/
+ LOGGER.debug(MessageFormatter.format("Adding id={0} usage={1}", id, usage));
+ MEASUREMENT_HUGE_PAGE huge_page = new MEASUREMENT_HUGE_PAGE();
+ assert(huge_page != null);
+ huge_page.hugePagesIdentifier = id;
+ huge_page.bytesUsed = usage;
+ huge_page.bytesFree = new EvelOptionDouble();
+ huge_page.percentFree = new EvelOptionDouble();
+ huge_page.percentUsed = new EvelOptionDouble();
+ huge_page.vmPageNumberFree = new EvelOptionDouble();
+ huge_page.vmPageNumberUsed = new EvelOptionDouble();
+
+
+ if( huge_pages == null ){
+ huge_pages = new ArrayList<MEASUREMENT_HUGE_PAGE>();
+ LOGGER.debug("Allocate new cpu usage");
+ }
+
+ huge_pages.add(huge_page);
+
+ EVEL_EXIT();
+ return huge_page;
+ }
+
+
+ /**************************************************************************//**
+ * Set Number of free hugepages in bytes
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param string double
+ *****************************************************************************/
+
+
+// public void evel_measurement_huge_page_hugePagesIdentifier_set(MEASUREMENT_HUGE_PAGE huge_page,
+// String string)
+// {
+// EVEL_ENTER();
+// huge_page.SetValuePr(string,"CPU hugePagesIdentifier");
+// EVEL_EXIT();
+//
+//
+// }
+ /**************************************************************************//**
+ * Set Number of free hugepages in percent
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_huge_page_percentFree_set(MEASUREMENT_HUGE_PAGE huge_page,
+ double val)
+ {
+ EVEL_ENTER();
+ huge_page.percentFree.SetValuePr(val,"Number of free hugepages in percent");
+ EVEL_EXIT();
+
+
+ }
+
+ /**************************************************************************//**
+ * Set Number of used hugepages in percent
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_huge_page_percentUsed_set(MEASUREMENT_HUGE_PAGE huge_page,
+ double val)
+ {
+ EVEL_ENTER();
+ huge_page.percentUsed.SetValuePr(val,"Number of used hugepages in percent");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Number of used hugepages in numbers
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_huge_page_vmPageNumberFree_set(MEASUREMENT_HUGE_PAGE huge_page,
+ double val)
+ {
+ EVEL_ENTER();
+ huge_page.vmPageNumberFree.SetValuePr(val,"Number of used hugepages in numbers");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Number of used hugepages in numbers
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_huge_page_vmPageNumberUsed_set(MEASUREMENT_HUGE_PAGE huge_page,
+ double val)
+ {
+ EVEL_ENTER();
+ huge_page.vmPageNumberUsed.SetValuePr(val,"Number of used hugepages in numbers");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Number of used hugepages in numbers
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_huge_page_bytesFree_set(MEASUREMENT_HUGE_PAGE huge_page,
+ double val)
+ {
+ EVEL_ENTER();
+ huge_page.bytesFree.SetValuePr(val,"Number of used hugepages in numbers");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
* Add an additional CPU usage value name/value pair to the Measurement.
*
* The name and value are null delimited ASCII strings. The library takes
@@ -640,7 +2276,16 @@ public class EvelScalingMeasurement extends EvelHeader { cpu_use.sys = new EvelOptionDouble();
cpu_use.user = new EvelOptionDouble();
cpu_use.wait = new EvelOptionDouble();
-
+ /*
+ * Ves6.0 Added Fields 14/07/2018
+ */
+ cpu_use.cpuCapacityContention= new EvelOptionDouble();
+ cpu_use.cpuDemandAvg= new EvelOptionDouble();
+ cpu_use.cpuDemandMhz= new EvelOptionDouble();
+ cpu_use.cpuDemandPct= new EvelOptionDouble();
+ cpu_use.cpuLatencyAvg= new EvelOptionDouble();
+ cpu_use.cpuOverheadAvg= new EvelOptionDouble();
+ cpu_use.cpuSwapWaitTime= new EvelOptionDouble();
if( cpu_usage == null ){
cpu_usage = new ArrayList<MEASUREMENT_CPU_USE>();
LOGGER.debug("Allocate new cpu usage");
@@ -651,6 +2296,131 @@ public class EvelScalingMeasurement extends EvelHeader { EVEL_EXIT();
return cpu_use;
}
+ /**************************************************************************//**
+ * Set the amount of time the CPU cannot run due to centention, in milliseconds.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+
+
+ public void evel_measurement_cpu_use_cpuCapacityContention_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuCapacityContention.SetValuePr(val,"CPU cpuCapacityContention");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set the total CPU time that the VNF/VNFC/VM could use if there is no contention, in milliseconds.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuDeamandAvg_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuDemandAvg.SetValuePr(val,"Total CPU Time");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set CPU demand as a percentage of the provisioned capacity.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuDeamandPct_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuDemandPct.SetValuePr(val,"CPU Demand as a percentage");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set CPU demand in megahertz.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuDeamandMhz_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuDemandMhz.SetValuePr(val,"CPU demand in megahertz");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Percentage of time the VM is unable to run because it is contending for access to the physical CPUs.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuLatencyAvg_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuLatencyAvg.SetValuePr(val,"CPU Percentage of time");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set The overhead demand above available allocations and reservations.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuOverheadAvg_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuOverheadAvg.SetValuePr(val,"CPU overhead demand");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set CPU Swap wait time in milliseconds.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param cpu_use Pointer to the CPU Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_cpu_use_cpuSwapWaitTime_set(MEASUREMENT_CPU_USE cpu_use,
+ double val)
+ {
+ EVEL_ENTER();
+ cpu_use.cpuSwapWaitTime.SetValuePr(val,"CPU Swap wait time");
+ EVEL_EXIT();
+ }
+
+
+
/**************************************************************************//**
* Set the CPU Idle value in measurement interval
@@ -806,7 +2576,7 @@ public class EvelScalingMeasurement extends EvelHeader { EVEL_EXIT();
}
-
+
/**************************************************************************//**
* Add an additional Memory usage value name/value pair to the Measurement.
*
@@ -822,7 +2592,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @return Returns pointer to memory use structure in measurements
*****************************************************************************/
public MEASUREMENT_MEM_USE evel_measurement_new_mem_use_add(
- String id, String vmidentifier, double membuffsz)
+ String vmidentifier, double membuffsz)
{
MEASUREMENT_MEM_USE mem_use = null;
EVEL_ENTER();
@@ -831,16 +2601,16 @@ public class EvelScalingMeasurement extends EvelHeader { /* Check assumptions. */
/***************************************************************************/
assert(event_domain == EvelHeader.DOMAINS.EVEL_DOMAIN_MEASUREMENT);
- assert(id != null);
+ // assert(id != null);
assert(membuffsz >= 0.0);
/***************************************************************************/
/* Allocate a container for the value and push onto the list. */
/***************************************************************************/
- LOGGER.debug(MessageFormatter.format("Adding id={0} buffer size={1}", id, membuffsz));
+ LOGGER.debug(MessageFormatter.format("Adding buffer size={1}", membuffsz));
mem_use = new MEASUREMENT_MEM_USE();
assert(mem_use != null);
- mem_use.id = id;
+ // mem_use.id = id;
mem_use.vmid = vmidentifier;
mem_use.membuffsz = membuffsz;
mem_use.memcache = new EvelOptionDouble();
@@ -849,6 +2619,17 @@ public class EvelScalingMeasurement extends EvelHeader { mem_use.slabrecl= new EvelOptionDouble();
mem_use.slabunrecl= new EvelOptionDouble();
mem_use.memused= new EvelOptionDouble();
+
+
+
+ mem_use.memoryDemand= new EvelOptionDouble();
+ mem_use.memoryLatencyAvg= new EvelOptionDouble();
+ mem_use.memorySharedAvg= new EvelOptionDouble();
+ mem_use.memorySwapInAvg= new EvelOptionDouble();
+ mem_use.memorySwapInRateAvg= new EvelOptionDouble();
+ mem_use.memorySwapOutAvg= new EvelOptionDouble();
+ mem_use.memorySwapOutRateAvg= new EvelOptionDouble();
+ mem_use.memorySwapUsedAvg= new EvelOptionDouble();
assert(mem_use.id != null);
@@ -972,7 +2753,159 @@ public class EvelScalingMeasurement extends EvelHeader { mem_use.memused.SetValuePr(val, "Memory usedup total set");
EVEL_EXIT();
}
+
+
+ /*
+ * VES6.0 Added Fields 14July
+ */
+ /**************************************************************************//**
+ * Set the Host demand in kibibytes.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memoryDemand_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memoryDemand.SetValuePr(val, "Host demand in kibibytes");
+ EVEL_EXIT();
+ }
+
+
+ /**************************************************************************//**
+ * Set Percentage of time the VM is waiting to access swapped or compressed memory.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memoryLatencyAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memoryLatencyAvg.SetValuePr(val, "Percentage of time the VM is waiting to access swapped or compressed memory");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Space used for caching swapped pages in the host cache in kibibytes.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySharedAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySharedAvg.SetValuePr(val, "Space used for caching swapped pages in the host cache in kibibytes");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Amount of memory swapped-in from host cache in kibibytes.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySwapInAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySwapInAvg.SetValuePr(val, "Amount of memory swapped-in from host cache in kibibytes.");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Rate at which memory is swapped from disk into active memory during the interval in kilobyte per second.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySwapInRateAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySwapInRateAvg.SetValuePr(val, "Rate at which memory is swapped from disk into active memory during the interval in kilobyte per second.");
+ EVEL_EXIT();
+ }
+
+
+ /**************************************************************************//**
+ * Set Amount of memory swapped-out to host cache in kibibytes
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySwapOutAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySwapOutAvg.SetValuePr(val, "Amount of memory swapped-out to host cache in kibibytes.");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Rate at which memory is being swapped from active memory to disk during the current interval in kilobytes per second.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySwapOutRateAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySwapOutRateAvg.SetValuePr(val, "Rate at which memory is being swapped from active memory to disk during the current interval in kilobytes per second");
+ EVEL_EXIT();
+ }
+
+ /**************************************************************************//**
+ * Set Space used for caching swapped pages in the host cache in kibibytes.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param mem_use Pointer to the Memory Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_mem_use_memorySwapUsedAvg_set(MEASUREMENT_MEM_USE mem_use,
+ double val)
+ {
+ EVEL_ENTER();
+ mem_use.memorySwapUsedAvg.SetValuePr(val, "Space used for caching swapped pages in the host cache in kibibytes.");
+ EVEL_EXIT();
+ }
+
+
/**************************************************************************//**
* Add an additional Disk usage value name/value pair to the Measurement.
*
@@ -1044,6 +2977,27 @@ public class EvelScalingMeasurement extends EvelHeader { disk_use.timewritelast= new EvelOptionDouble();
disk_use.timewritemax= new EvelOptionDouble();
disk_use.timewritemin= new EvelOptionDouble();
+ /*
+ *
+ */
+ disk_use.diskBusResets=new EvelOptionDouble();
+ disk_use.diskCommandsAborted=new EvelOptionDouble();
+ disk_use.diskCommandsAvg=new EvelOptionDouble();
+ disk_use.diskFlushRequests=new EvelOptionDouble();
+ disk_use.diskFlushTime=new EvelOptionDouble();
+ disk_use.diskReadCommandsAvg=new EvelOptionDouble();
+ disk_use.diskTime=new EvelOptionDouble();
+ disk_use.diskTotalReadLatencyAvg=new EvelOptionDouble();
+ disk_use.diskWriteCommandsAvg=new EvelOptionDouble();
+ disk_use.diskTotalWriteLatencyAvg=new EvelOptionDouble();
+
+
+ disk_use.diskWeightedIoTimeAvg=new EvelOptionDouble();
+ disk_use.diskWeightedIoTimeLast=new EvelOptionDouble();
+ disk_use.diskWeightedIoTimeMax=new EvelOptionDouble();
+ disk_use.diskWeightedIoTimeMin=new EvelOptionDouble();
+
+
if( disk_usage == null ){
disk_usage = new ArrayList<MEASUREMENT_DISK_USE>();
@@ -1057,7 +3011,235 @@ public class EvelScalingMeasurement extends EvelHeader { EVEL_EXIT();
return disk_use;
}
+
+ /*
+ * Ves 6.0 19/07/2018
+ */
+
+ /**************************************************************************//**
+ * Set milliseconds spent doing input/output operations over 1 sec; treat
+ * this metric as a device load percentage where 1000ms matches 100% load;
+ * provide the average over the measurement interval
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+
+ public void evel_measurement_disk_use_diskWeightedIoTimeAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskWeightedIoTimeAvg.SetValuePr(val,"average within the collection interval");
+ EVEL_EXIT();
+ }
+
+
+ public void evel_measurement_disk_use_diskWeightedIoTimeLast_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskWeightedIoTimeLast.SetValuePr(val,"last within the collection interval.");
+ EVEL_EXIT();
+ }
+
+ public void evel_measurement_disk_use_diskWeightedIoTimeMax_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskWeightedIoTimeMax.SetValuePr(val,"maximum within the collection interval.");
+ EVEL_EXIT();
+ }
+
+ public void evel_measurement_disk_use_diskWeightedIoTimeMin_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskWeightedIoTimeMin.SetValuePr(val,"minimum within the collection interval.");
+ EVEL_EXIT();
+ }
+
+
+
+
+ /*
+ * *************************************
+ */
+
+ /**************************************************************************//**
+ * Set milliseconds spent doing input/output operations over 1 sec; treat
+ * this metric as a device load percentage where 1000ms matches 100% load;
+ * provide the average over the measurement interval
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskBusResets_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskBusResets.SetValuePr(val,"Disk Bus Resets");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set milliseconds spent doing input/output operations over 1 sec; treat
+ * this metric as a device load percentage where 1000ms matches 100% load;
+ * provide the average over the measurement interval
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskCommandsAborted_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskCommandsAborted.SetValuePr(val,"Disk ioload set");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Average number of commands per second.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskCommandsAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskCommandsAvg.SetValuePr(val,"Average number of commands per second");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Total flush requests of the disk cache.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskFlushRequests_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskFlushRequests.SetValuePr(val,"Total flush requests");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Average number of read commands issued per second to the disk during the collection interval.
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskReadCommandsAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskReadCommandsAvg.SetValuePr(val,"Average number of read commands issued per second to the disk during the collection interval.");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Total time spent on disk cache flushing in milliseconds.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskFlushTime_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskFlushTime.SetValuePr(val,"Total time spent on disk cache flushing in milliseconds.");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Total time spent on disk cache reads/writes in nanoseconds
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskTime_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskTime.SetValuePr(val,"Total time spent on disk cache reads/writes in nanoseconds");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set The average amount of time taken for a read from the perspective of a Guest OS. This is the sum of Kernel Read Latency and Physical Device Read Latency.
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskTotalReadLatencyAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskTotalReadLatencyAvg.SetValuePr(val,"The average amount of time taken for a read from the perspective of a Guest OS. This is the sum of Kernel Read Latency and Physical Device Read Latency.");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set The average amount of time taken for a write from the perspective of a Guest OS. This is the sum of Kernel Write Latency and Physical Device Write Latency.
+ *
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskTotalWriteLatencyAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskTotalWriteLatencyAvg.SetValuePr(val,"The average amount of time taken for a write from the perspective of a Guest OS. This is the sum of Kernel Write Latency and Physical Device Write Latency.");
+ EVEL_EXIT();
+ }
+ /**************************************************************************//**
+ * Set Average number of write commands issued per second to the disk during the collection interval.
+ * @note The property is treated as immutable: it is only valid to call
+ * the setter once. However, we don't assert if the caller tries to
+ * overwrite, just ignoring the update instead.
+ *
+ * @param disk_use Pointer to the Disk Use.
+ * @param val double
+ *****************************************************************************/
+ public void evel_measurement_disk_use_diskWriteCommandsAvg_set(MEASUREMENT_DISK_USE disk_use,
+ double val)
+ {
+ EVEL_ENTER();
+ disk_use.diskWriteCommandsAvg.SetValuePr(val,"Average number of write commands issued per second to the disk during the collection interval.");
+ EVEL_EXIT();
+ }
/**************************************************************************//**
* Set milliseconds spent doing input/output operations over 1 sec; treat
* this metric as a device load percentage where 1000ms matches 100% load;
@@ -1822,7 +4004,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param ephemeral_used Ephemeral storage in use.
* @param ephemeral_iops Ephemeral storage IOPS.
*****************************************************************************/
- public void evel_measurement_fsys_use_add(
+ public MEASUREMENT_FSYS_USE evel_measurement_fsys_use_add(
String filesystem_name,
double block_configured,
double block_used,
@@ -1868,6 +4050,8 @@ public class EvelScalingMeasurement extends EvelHeader { filesystem_usage.add(fsys_use);
EVEL_EXIT();
+
+ return fsys_use;
}
/**************************************************************************//**
@@ -1881,7 +4065,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param feature ASCIIZ string with the feature's name.
* @param utilization Utilization of the feature.
*****************************************************************************/
- public void evel_measurement_feature_use_add(
+ public MEASUREMENT_FEATURE_USE evel_measurement_feature_use_add(
String feature,
int utilization)
{
@@ -1913,6 +4097,7 @@ public class EvelScalingMeasurement extends EvelHeader { feature_usage.add(feature_use);
EVEL_EXIT();
+ return feature_use;
}
/**************************************************************************//**
@@ -2013,7 +4198,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param codec ASCIIZ string with the codec's name.
* @param utilization Number of codecs in use.
*****************************************************************************/
- public void evel_measurement_codec_use_add( String codec,
+ public MEASUREMENT_CODEC_USE evel_measurement_codec_use_add( String codec,
int utilization )
{
MEASUREMENT_CODEC_USE codec_use = null;
@@ -2043,6 +4228,8 @@ public class EvelScalingMeasurement extends EvelHeader { codec_usage.add(codec_use);
EVEL_EXIT();
+
+ return codec_use;
}
@@ -2210,6 +4397,8 @@ public class EvelScalingMeasurement extends EvelHeader { latency_distribution.add(bucket);
EVEL_EXIT();
+
+
}
/**************************************************************************//**
@@ -2222,7 +4411,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param high_end High end of the bucket's range.
* @param count Count of events in this bucket.
*****************************************************************************/
- public void evel_measurement_latency_add(
+ public MEASUREMENT_LATENCY_BUCKET evel_measurement_latency_add(
double low_end,
double high_end,
int count)
@@ -2240,29 +4429,31 @@ public class EvelScalingMeasurement extends EvelHeader { evel_meas_latency_bucket_add(bucket);
EVEL_EXIT();
+
+ return bucket;
}
/**************************************************************************//**
* Create a new vNIC Use to be added to a Measurement event.
*
- * @note The mandatory fields on the ::MEASUREMENT_VNIC_PERFORMANCE must be supplied
+ * @note The mandatory fields on the ::MEASUREMENT_NIC_PERFORMANCE must be supplied
* to this factory function and are immutable once set. Optional
* fields have explicit setter functions, but again values may only be
- * set once so that the ::MEASUREMENT_VNIC_PERFORMANCE has immutable
+ * set once so that the ::MEASUREMENT_NIC_PERFORMANCE has immutable
* properties.
*
* @param vnic_id ASCIIZ string with the vNIC's ID.
* @param val_suspect True or false confidence in data.
*
- * @returns pointer to the newly manufactured ::MEASUREMENT_VNIC_PERFORMANCE.
+ * @returns pointer to the newly manufactured ::MEASUREMENT_NIC_PERFORMANCE.
* If the structure is not used it must be released using
* ::evel_measurement_free_vnic_performance.
* @retval null Failed to create the vNIC Use.
*****************************************************************************/
- public MEASUREMENT_VNIC_PERFORMANCE evel_measurement_new_vnic_performance(String vnic_id,
- String val_suspect)
+ public MEASUREMENT_NIC_PERFORMANCE evel_measurement_new_vnic_performance(String vnic_id,
+ String val_suspect)
{
- MEASUREMENT_VNIC_PERFORMANCE vnic_perf=null;
+ MEASUREMENT_NIC_PERFORMANCE vnic_perf=null;
EVEL_ENTER();
@@ -2276,11 +4467,14 @@ public class EvelScalingMeasurement extends EvelHeader { /* Allocate, then set Mandatory Parameters. */
/***************************************************************************/
- vnic_perf = new MEASUREMENT_VNIC_PERFORMANCE();
+ vnic_perf = new MEASUREMENT_NIC_PERFORMANCE();
assert(vnic_perf != null);
vnic_perf.vnic_id = vnic_id;
vnic_perf.valuesaresuspect = val_suspect;
+ //VES6.0 added field 14July
+ //vnic_perf.nicIdentifier = nicIdentifier;
+
vnic_perf.recvd_bcast_packets_acc= new EvelOptionDouble();
vnic_perf.recvd_bcast_packets_delta= new EvelOptionDouble();
@@ -2311,6 +4505,19 @@ public class EvelScalingMeasurement extends EvelHeader { vnic_perf.tx_ucast_packets_acc= new EvelOptionDouble();
vnic_perf.tx_ucast_packets_delta= new EvelOptionDouble();
+
+ vnic_perf.administrativeState= new EvelOptionDouble();
+ vnic_perf.operationalState= new EvelOptionDouble();
+ vnic_perf.receivedPercentDiscard= new EvelOptionDouble();
+ vnic_perf.receivedPercentError= new EvelOptionDouble();
+ vnic_perf.receivedUtilization= new EvelOptionDouble();
+ vnic_perf.speed= new EvelOptionString();
+ vnic_perf.transmittedPercentDiscard= new EvelOptionDouble();
+ vnic_perf.transmittedPercentError= new EvelOptionDouble();
+ vnic_perf.transmittedUtilization= new EvelOptionDouble();
+
+
+
LOGGER.debug("Adding "+vnic_perf+"VNIC ID="+ vnic_perf.vnic_id+"Value="+vnic_perf.valuesaresuspect);
/***************************************************************************/
@@ -2334,7 +4541,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_bcast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_bcast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_bcast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_bcast_packets_acc)
{
EVEL_ENTER();
@@ -2362,7 +4569,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_bcast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_bcast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_bcast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_bcast_packets_delta)
{
EVEL_ENTER();
@@ -2391,7 +4598,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_discard_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_discard_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_discard_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_discard_packets_acc)
{
EVEL_ENTER();
@@ -2419,7 +4626,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_discard_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_discard_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_discard_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_discard_packets_delta)
{
EVEL_ENTER();
@@ -2448,7 +4655,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_error_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_error_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_error_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_error_packets_acc)
{
EVEL_ENTER();
@@ -2476,7 +4683,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_error_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_error_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_error_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_error_packets_delta)
{
EVEL_ENTER();
@@ -2504,7 +4711,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_mcast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_mcast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_mcast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_mcast_packets_acc)
{
EVEL_ENTER();
@@ -2532,7 +4739,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_mcast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_mcast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_mcast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_mcast_packets_delta)
{
EVEL_ENTER();
@@ -2560,7 +4767,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_octets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_octets_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_octets_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_octets_acc)
{
EVEL_ENTER();
@@ -2588,7 +4795,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_octets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_octets_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_octets_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_octets_delta)
{
EVEL_ENTER();
@@ -2616,7 +4823,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_total_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_total_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_total_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_total_packets_acc)
{
EVEL_ENTER();
@@ -2644,7 +4851,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_total_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_total_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_total_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_total_packets_delta)
{
EVEL_ENTER();
@@ -2672,7 +4879,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_ucast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_rx_ucast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_ucast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_ucast_packets_acc)
{
EVEL_ENTER();
@@ -2700,7 +4907,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param recvd_ucast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_rx_ucast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_rx_ucast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double recvd_ucast_packets_delta)
{
EVEL_ENTER();
@@ -2728,7 +4935,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_bcast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_bcast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_bcast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_bcast_packets_acc)
{
EVEL_ENTER();
@@ -2756,7 +4963,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_bcast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_bcast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_bcast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_bcast_packets_delta)
{
EVEL_ENTER();
@@ -2784,7 +4991,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_discarded_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_discarded_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_discarded_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_discarded_packets_acc)
{
EVEL_ENTER();
@@ -2812,7 +5019,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_discarded_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_discarded_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_discarded_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_discarded_packets_delta)
{
EVEL_ENTER();
@@ -2840,7 +5047,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_error_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_error_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_error_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_error_packets_acc)
{
EVEL_ENTER();
@@ -2868,7 +5075,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_error_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_error_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_error_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_error_packets_delta)
{
EVEL_ENTER();
@@ -2896,7 +5103,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_mcast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_mcast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_mcast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_mcast_packets_acc)
{
EVEL_ENTER();
@@ -2924,7 +5131,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_mcast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_mcast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_mcast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_mcast_packets_delta)
{
EVEL_ENTER();
@@ -2952,7 +5159,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_octets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_octets_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_octets_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_octets_acc)
{
EVEL_ENTER();
@@ -2980,7 +5187,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_octets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_octets_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_octets_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_octets_delta)
{
EVEL_ENTER();
@@ -3009,7 +5216,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_total_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_total_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_total_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_total_packets_acc)
{
EVEL_ENTER();
@@ -3037,7 +5244,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_total_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_total_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_total_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_total_packets_delta)
{
EVEL_ENTER();
@@ -3066,7 +5273,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_ucast_packets_acc
*****************************************************************************/
- public void evel_vnic_performance_tx_ucast_pkt_acc_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_ucast_pkt_acc_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_ucast_packets_acc)
{
EVEL_ENTER();
@@ -3094,7 +5301,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use.
* @param tx_ucast_packets_delta
*****************************************************************************/
- public void evel_vnic_performance_tx_ucast_pkt_delta_set(MEASUREMENT_VNIC_PERFORMANCE vnic_performance,
+ public void evel_vnic_performance_tx_ucast_pkt_delta_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
double tx_ucast_packets_delta)
{
EVEL_ENTER();
@@ -3110,6 +5317,159 @@ public class EvelScalingMeasurement extends EvelHeader { EVEL_EXIT();
}
+
+ /*
+ * VES6.0 UPDATE 19JULY
+ */
+
+ public void evel_vnic_performance_administrativeState_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double administrativeState)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(administrativeState >= 0.0);
+
+ vnic_performance.administrativeState.SetValuePr(
+ administrativeState,"Administrative State");
+
+ EVEL_EXIT();
+ }
+
+
+
+ public void evel_vnic_performance_operationalState_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double operationalState)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(operationalState >= 0.0);
+
+ vnic_performance.operationalState.SetValuePr(
+ operationalState,"operational State");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_receivedPercentDiscard_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double receivedPercentDiscard)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(receivedPercentDiscard >= 0.0);
+
+ vnic_performance.receivedPercentDiscard.SetValuePr(
+ receivedPercentDiscard,"Received Percent Discard");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_receivedPercentError_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double receivedPercentError)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(receivedPercentError >= 0.0);
+
+ vnic_performance.receivedPercentError.SetValuePr(
+ receivedPercentError,"Received Percent Error");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_receivedUtilization_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double receivedUtilization)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(receivedUtilization >= 0.0);
+
+ vnic_performance.receivedUtilization.SetValuePr(
+ receivedUtilization,"Received Utilization");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_speed_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ String speed)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(speed != null);
+
+ vnic_performance.speed.SetValuePr(
+ speed,"Speed");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_transmittedPercentDiscard_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double transmittedPercentDiscard)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(transmittedPercentDiscard >= 0.0);
+
+ vnic_performance.transmittedPercentDiscard.SetValuePr(
+ transmittedPercentDiscard,"Transmitted Percent Discard");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_transmittedPercentError_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double transmittedPercentError)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(transmittedPercentError >= 0.0);
+
+ vnic_performance.transmittedPercentError.SetValuePr(
+ transmittedPercentError,"Transmitted Percent Error");
+
+ EVEL_EXIT();
+ }
+
+ public void evel_vnic_performance_transmittedUtilization_set(MEASUREMENT_NIC_PERFORMANCE vnic_performance,
+ double transmittedUtilization)
+ {
+ EVEL_ENTER();
+
+ /***************************************************************************/
+ /* Check preconditions. */
+ /***************************************************************************/
+ assert(transmittedUtilization >= 0.0);
+
+ vnic_performance.transmittedUtilization.SetValuePr(
+ transmittedUtilization,"transmittedUtilization");
+
+ EVEL_EXIT();
+ }
+
+
+
/**************************************************************************//**
@@ -3119,7 +5479,7 @@ public class EvelScalingMeasurement extends EvelHeader { * @param vnic_performance Pointer to the vNIC Use to add.
*****************************************************************************/
public void evel_meas_vnic_performance_add(
- MEASUREMENT_VNIC_PERFORMANCE vnic_performance)
+ MEASUREMENT_NIC_PERFORMANCE vnic_performance)
{
EVEL_ENTER();
@@ -3131,7 +5491,7 @@ public class EvelScalingMeasurement extends EvelHeader { assert(vnic_performance != null);
if( vnic_usage == null ){
- vnic_usage = new ArrayList<MEASUREMENT_VNIC_PERFORMANCE>();
+ vnic_usage = new ArrayList<MEASUREMENT_NIC_PERFORMANCE>();
LOGGER.debug("Allocate new file system usage");
}
@@ -3183,6 +5543,9 @@ public class EvelScalingMeasurement extends EvelHeader { public void evel_measurement_vnic_performance_add(
String vnic_id,
String valset,
+ //VES6.0 added field 14July
+ //String nicIdentifier,
+ String speed,
double recvd_bcast_packets_acc,
double recvd_bcast_packets_delta,
double recvd_discarded_packets_acc,
@@ -3210,14 +5573,26 @@ public class EvelScalingMeasurement extends EvelHeader { double tx_total_packets_acc,
double tx_total_packets_delta,
double tx_ucast_packets_acc,
- double tx_ucast_packets_delta)
+ double tx_ucast_packets_delta,
+ //VES6.0 addded fileds 19July
+ double administrativeState,
+ double operationalState,
+ double receivedPercentDiscard,
+ double receivedPercentError,
+ double receivedUtilization,
+
+ double transmittedPercentDiscard,
+ double transmittedPercentError,
+ double transmittedUtilization
+ )
{
- MEASUREMENT_VNIC_PERFORMANCE vnic_performance = null;
+ MEASUREMENT_NIC_PERFORMANCE vnic_performance = null;
EVEL_ENTER();
/***************************************************************************/
/* Trust the assertions in the underlying methods. */
/***************************************************************************/
+ //VES6.0 added field 14July
vnic_performance = evel_measurement_new_vnic_performance(vnic_id, valset);
evel_vnic_performance_rx_bcast_pkt_acc_set(vnic_performance, recvd_bcast_packets_acc);
@@ -3249,8 +5624,23 @@ public class EvelScalingMeasurement extends EvelHeader { evel_vnic_performance_tx_ucast_pkt_acc_set(vnic_performance, tx_ucast_packets_acc);
evel_vnic_performance_tx_ucast_pkt_delta_set(vnic_performance, tx_ucast_packets_delta);
+ //VES6.0 added fields 19July
+
+ evel_vnic_performance_administrativeState_set(vnic_performance, administrativeState);
+ evel_vnic_performance_operationalState_set(vnic_performance, operationalState);
+ evel_vnic_performance_receivedPercentDiscard_set(vnic_performance, receivedPercentDiscard);
+ evel_vnic_performance_receivedPercentError_set(vnic_performance, receivedPercentError);
+ evel_vnic_performance_receivedUtilization_set(vnic_performance, receivedUtilization);
+ evel_vnic_performance_speed_set(vnic_performance, speed);
+ evel_vnic_performance_transmittedPercentDiscard_set(vnic_performance, transmittedPercentDiscard);
+ evel_vnic_performance_transmittedPercentError_set(vnic_performance, transmittedPercentError);
+ evel_vnic_performance_transmittedUtilization_set(vnic_performance, transmittedUtilization);
+
+
+
+
if( vnic_usage == null ){
- vnic_usage = new ArrayList<MEASUREMENT_VNIC_PERFORMANCE>();
+ vnic_usage = new ArrayList<MEASUREMENT_NIC_PERFORMANCE>();
LOGGER.debug("Allocate new file system usage");
}
@@ -3292,6 +5682,7 @@ public class EvelScalingMeasurement extends EvelHeader { *
* @retval JSON Object of Scaling Measurement event
*****************************************************************************/
+ @SuppressWarnings("null")
JsonObjectBuilder evelScalingMeasurementObject()
{
MEASUREMENT_CPU_USE cpu_use = null;
@@ -3299,17 +5690,36 @@ public class EvelScalingMeasurement extends EvelHeader { MEASUREMENT_DISK_USE disk_use = null;
MEASUREMENT_FSYS_USE fsys_use = null;
MEASUREMENT_LATENCY_BUCKET bucket = null;
- MEASUREMENT_VNIC_PERFORMANCE vnic_use = null;
+ MEASUREMENT_NIC_PERFORMANCE nic_use = null;
MEASUREMENT_FEATURE_USE feature_use = null;
MEASUREMENT_CODEC_USE codec_use = null;
MEASUREMENT_GROUP meas_group = null;
CUSTOM_MEASUREMENT custom_meas = null;
+
+ MEASUREMENT_IPMI ipmij = null;
+ MEASUREMENT_LOAD load = null;
+ MEASUREMENT_PROCESS_STATS process_stats = null;
+ MACHINE_CHECK_EXCEPTION check_exception = null;
+
+ MEASUREMENT_HUGE_PAGE hugePage = null;
+
+
+ MEASUREMENT_IPMI_PROCESSOR ipmiProcessorJson = null;
+ IPMIglobalAggregateTemperatureMargin ipmiGlobalAggTempMarginJson;
+ Processor_DIMMaggregate_Thermal_Margin ipmiProcessorDIMMagregatejson = null;
+ IPMIpowerSupply ipmiPowerSupplyJson;
+ IPMIbattery ipmiBatteryJson;
+ IPMINIC ipmiNicJson;
+ IPMIHSBP ipmiHsbpJson;
+ IPMIbaseboardTemperature ipmiBaseBoardTempJson;
+ IPMIbaseboardvoltageResulator ipmiBaseboardVoltageResultatorJson;
+ IPMIfan ipmifanjson;
//DLIST_ITEM item = null;
//DLIST_ITEM nested_item = null;
//DLIST_ITEM addl_info_item = null;
//OTHER_FIELD addl_info = null;
- double version = major_version+(double)minor_version/10;
-
+// double version = major_version+(double)minor_version/10;
+ String version = "4.0";
EVEL_ENTER();
/***************************************************************************/
@@ -3327,26 +5737,143 @@ public class EvelScalingMeasurement extends EvelHeader { /* Optional fields. */
/***************************************************************************/
// additional fields
- if( additional_info != null )
- {
- JsonArrayBuilder builder = Json.createArrayBuilder();
- for(int i=0;i<additional_info.size();i++) {
- String[] addl_info = additional_info.get(i);
- JsonObject obj = Json.createObjectBuilder()
- .add("name", addl_info[0])
- .add("value", addl_info[1]).build();
- builder.add(obj);
- }
- evelmeasmt.add("additionalFields", builder);
- }
+// if( additional_info != null )
+// {
+// JsonArrayBuilder builder = Json.createArrayBuilder();
+// for(int i=0;i<additional_info.size();i++) {
+// String[] addl_info = additional_info.get(i);
+// JsonObject obj = Json.createObjectBuilder()
+// .add("name", addl_info[0])
+// .add("value", addl_info[1]).build();
+// builder.add(obj);
+// }
+// evelmeasmt.add("additionalFields", builder);
+// }
+
+ if(additional_inf != null) {
+ JsonObjectBuilder builder = Json.createObjectBuilder();
+ //JsonArrayBuilder builder = Json.createArrayBuilder();
+ Iterator<Entry<String, String>> it = additional_inf.entrySet().iterator();
+ while(it.hasNext()) {
+ Map.Entry<String, String> add_inf = (Map.Entry<String, String>)it.next();
+ String addl_info_key = add_inf.getKey();
+ String addl_info_value = add_inf.getValue();
+// JsonObject obj1 = Json.createObjectBuilder()
+// .add("name", addl_info_key)
+// .add("value", addl_info_value).build();
+ builder.add(addl_info_key, addl_info_value);
+ }
+ evelmeasmt.add("additionalFields", builder);
+ }
// TBD additional json objects
if( concurrent_sessions.is_set )
evelmeasmt.add("concurrentSessions", concurrent_sessions.GetValue());
if( configured_entities.is_set )
evelmeasmt.add("configuredEntities", configured_entities.GetValue());
-
+ /*******************************************************************************
+ * MEASUREMENT Load
+ *******************************************************************************/
+ if(loads != null && loads.size() >0) {
+ JsonArrayBuilder builder = Json.createArrayBuilder();
+ for(int i=0;i<loads.size();i++) {
+ load = loads.get(i);
+ JsonObjectBuilder obj = Json.createObjectBuilder();
+ // .add("loadIdentifier", load.loadIdentifier);
+ load.longTerm.encJsonValue(obj,"longTerm");
+ load.midTerm.encJsonValue(obj,"midTerm");
+ load.shortTerm.encJsonValue(obj,"shortTerm");
+ builder.add(obj.build());
+
+ }
+ evelmeasmt.add("loadArray", builder);
+ }
+
+ /***************************************************************************/
+ /* process_stats */
+ /***************************************************************************/
+ if(this.process_stats!=null && this.process_stats.size()>0) {
+
+ JsonArrayBuilder builder = Json.createArrayBuilder();
+ for(int i=0;i<this.process_stats.size();i++) {
+ process_stats = this.process_stats.get(i);
+ JsonObjectBuilder obj = Json.createObjectBuilder()
+ .add("processIdentifier", process_stats.processIdentifier);
+ process_stats.forkRate.encJsonValue(obj, "forkRate");
+ process_stats.psStateBlocked.encJsonValue(obj, "psStateBlocked");
+ process_stats.psStatePaging.encJsonValue(obj, "psStatePaging");
+ process_stats.psStateRunning.encJsonValue(obj, "psStateRunning");
+ process_stats.psStateSleeping.encJsonValue(obj, "psStateSleeping");
+ process_stats.psStateStopped.encJsonValue(obj, "psStateStopped");
+ process_stats.psStateZombie.encJsonValue(obj, "psStateZombie");
+
+ builder.add(obj.build());
+
+
+
+ }
+ evelmeasmt.add("processStatsArray", builder);
+ }
+
+ /***************************************************************************/
+ /* MACHINE_Check_Exception */
+ /***************************************************************************/
+ if( machineCheckException != null && machineCheckException.size()>0) {
+ JsonArrayBuilder builder = Json.createArrayBuilder();
+ for(int i=0;i<machineCheckException.size();i++) {
+ check_exception = machineCheckException.get(i);
+ JsonObjectBuilder obj = Json.createObjectBuilder()
+ .add( "vmIdentifier", check_exception.processIdentifier);
+ check_exception.correctedMemoryErrors.encJsonValue(obj, "correctedMemoryErrors");
+ check_exception.correctedMemoryErrors_In1Hr.encJsonValue(obj, "correctedMemoryErrorsIn1Hr");
+ check_exception.uncorrectedMemoryErrors.encJsonValue(obj, "uncorrectedMemoryErrors");
+ check_exception.uncorrectedMemoryErrors_In1Hr.encJsonValue(obj, "uncorrectedMemoryErrorsIn1Hr");
+
+ builder.add(obj.build());
+
+ }
+ evelmeasmt.add("machineCheckExceptionArray", builder);
+ }
+
+
+ /***************************************************************************/
+ /* MACHINE_Check_Exception */
+ /***************************************************************************/
+ if( huge_pages != null && huge_pages.size()>0) {
+ JsonArrayBuilder builder = Json.createArrayBuilder();
+ for(int i=0;i<huge_pages.size();i++) {
+ hugePage = huge_pages.get(i);
+ JsonObjectBuilder obj = Json.createObjectBuilder();
+ obj.add( "hugePagesIdentifier", hugePage.hugePagesIdentifier);
+ obj.add( "bytesUsed", hugePage.bytesUsed);
+
+
+
+ obj.add("bytesFree", hugePage.bytesFree.value);
+ obj.add("vmPageNumberUsed", hugePage.vmPageNumberUsed.value);
+ obj.add( "vmPageNumberFree", hugePage.vmPageNumberFree.value);
+ obj.add( "percentUsed", hugePage.percentUsed.value);
+ obj.add( "percentFree", hugePage.percentFree.value);
+
+// obj.add( "bytesFree", hugePage.bytesFree);
+// obj.add( "vmPageNumberUsed", hugePage.vmPageNumberUsed);
+// obj.add( "vmPageNumberFree", hugePage.vmPageNumberFree);
+// obj.add( "percentUsed", hugePage.percentUsed);
+// obj.add( "percentFree", hugePage.percentFree);
+
+
+// hugePage.correctedMemoryErrors.encJsonValue(obj, "correctedMemoryErrors");
+// hugePage.correctedMemoryErrors_In1Hr.encJsonValue(obj, "correctedMemoryErrorsIn1Hr");
+// hugePage.uncorrectedMemoryErrors.encJsonValue(obj, "uncorrectedMemoryErrors");
+// hugePage.uncorrectedMemoryErrors_In1Hr.encJsonValue(obj, "uncorrectedMemoryErrorsIn1Hr");
+
+ builder.add(obj.build());
+
+ }
+ evelmeasmt.add("hugePagesArray", builder);
+ }
+
/***************************************************************************/
/* CPU Use list. */
/***************************************************************************/
@@ -3366,14 +5893,224 @@ public class EvelScalingMeasurement extends EvelHeader { cpu_use.steal.encJsonValue(obj,"cpuUsageSteal");
cpu_use.sys.encJsonValue(obj,"cpuUsageSystem");
cpu_use.user.encJsonValue(obj,"cpuUsageUser");
- cpu_use.wait.encJsonValue(obj,"cpuWait");
-
+ cpu_use.wait.encJsonValue(obj,"cpuWait");
+ /*********************
+ * VES6.0 added fields 14/07/2018
+ */
+ cpu_use.cpuCapacityContention.encJsonValue(obj,"cpuCapacityContention");
+ cpu_use.cpuDemandAvg.encJsonValue(obj,"cpuDemandAvg");
+ cpu_use.cpuDemandMhz.encJsonValue(obj,"cpuDemandMhz");
+ cpu_use.cpuDemandPct.encJsonValue(obj,"cpuDemandPct");
+ cpu_use.cpuLatencyAvg.encJsonValue(obj,"cpuLatencyAvg");
+ cpu_use.cpuOverheadAvg.encJsonValue(obj,"cpuOverheadAvg");
+ cpu_use.cpuSwapWaitTime.encJsonValue(obj,"cpuSwapWaitTime");
builder.add(obj.build());
}
evelmeasmt.add("cpuUsageArray", builder);
}
-
+ if(ipmis != null && ipmis.size() > 0) {
+ JsonObjectBuilder builder1 = Json.createObjectBuilder();
+ JsonArrayBuilder builder = Json.createArrayBuilder();
+ System.out.println("ipmis size---"+ ipmis.size());
+ for(int i=0;i<ipmis.size();i++) {
+ ipmij = ipmis.get(i);
+ // JsonObjectBuilder obj= null;
+ JsonObjectBuilder obj = Json.createObjectBuilder();
+ ipmij.exitAirTemperature.encJsonValue(obj, "exitAirTemperature");
+ ipmij.frontPanelTemperature.encJsonValue(obj, "frontPanelTemperature");
+ ipmij.ioModuleTemperature.encJsonValue(obj, "ioModuleTemperature");
+ ipmij.systemAirflow.encJsonValue(obj, "systemAirflow");
+
+
+ if(ipmij.ipmiprocessor != null && ipmij.ipmiprocessor.size() > 0 ) {
+ JsonArrayBuilder ipmi_processor_builder = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiprocessor.size();j++) {
+ ipmiProcessorJson = ipmij.ipmiprocessor.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("processorIdentifier", ipmiProcessorJson.processorIdentifier);
+ ipmiProcessorJson.processorDTSthermalMargin.encJsonValue(obj1 , "processorDTSthermalMargin");
+ ipmiProcessorJson.processorThermalControlPercent.encJsonValue(obj1, "processorThermalControlPercent");
+ if(ipmiProcessorJson.processorDIMMaggregateThermalMargin != null &&
+ ipmiProcessorJson.processorDIMMaggregateThermalMargin.size() > 0) {
+ JsonArrayBuilder ipmi_procesor_DTS_thermal_margin = Json.createArrayBuilder();
+ for( int k=0 ;k<ipmiProcessorJson.processorDIMMaggregateThermalMargin.size();k++) {
+
+ ipmiProcessorDIMMagregatejson = ipmiProcessorJson.processorDIMMaggregateThermalMargin.get(k);
+ JsonObjectBuilder obj2 = Json.createObjectBuilder().add("processorDIMMaggregateThermalMarginIdentifier", ipmiProcessorDIMMagregatejson.processorDIMMaggregateThermalMarginIdentifier)
+ .add("processorDIMMaggregateThermalMargin", ipmiProcessorDIMMagregatejson.processorDIMMaggregateThermalMargin);
+
+ ipmi_procesor_DTS_thermal_margin.add(obj2.build());
+ }
+ obj1.add("processorDIMMaggregateThermalMargin", ipmi_procesor_DTS_thermal_margin );
+
+ }
+
+ ipmi_processor_builder.add(obj1.build());
+
+ }
+ // obj.add("ipmiProcessorArray", ipmi_processor_builder);
+ builder1.add("ipmiProcessorArray", ipmi_processor_builder);
+ }
+
+
+ if(ipmij.ipmiglobalAggregateTemperatureMarginArray != null &&
+ ipmij.ipmiglobalAggregateTemperatureMarginArray.size()>0) {
+
+ JsonArrayBuilder ipmi_global_aggregate_tepmerature_margin_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiglobalAggregateTemperatureMarginArray.size();j++) {
+ ipmiGlobalAggTempMarginJson = ipmij.ipmiglobalAggregateTemperatureMarginArray.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("globalAggregateTemperatureMarginIdentifier", ipmiGlobalAggTempMarginJson.globalAggregateTemperatureMarginIdentifier);
+ ipmiGlobalAggTempMarginJson.globalAggregateTemeratureMargin.encJsonValue(obj1, "globalAggregateTemeratureMargin");
+
+ ipmi_global_aggregate_tepmerature_margin_array.add(obj1.build());
+ }
+
+ // obj.add("globalAggregateTemperatureMarginArray", ipmi_global_aggregate_tepmerature_margin_array );
+ builder1.add("globalAggregateTemperatureMarginArray", ipmi_global_aggregate_tepmerature_margin_array);
+ }
+
+
+
+ if(ipmij.ipmipowerSupply != null &&
+ ipmij.ipmipowerSupply.size()>0) {
+
+ JsonArrayBuilder ipmi_power_supply_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmipowerSupply.size();j++) {
+ ipmiPowerSupplyJson = ipmij.ipmipowerSupply.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("powerSupplyIdentifier", ipmiPowerSupplyJson.powerSupplyIdentifier);
+ ipmiPowerSupplyJson.powerSupplycurrentOutputPercent.encJsonValue(obj1, "powerSupplycurrentOutputPercent");
+ ipmiPowerSupplyJson.powerSupplyInputPower.encJsonValue(obj1, "powerSupplyInputPower");
+ ipmiPowerSupplyJson.powerSupplyTemperature.encJsonValue(obj1, "powerSupplyTemperature");
+
+ ipmi_power_supply_array.add(obj1.build());
+ }
+
+ // obj.add("ipmiPowerSupplyArray", ipmi_power_supply_array );
+ builder1.add("ipmiPowerSupplyArray", ipmi_power_supply_array);
+ }
+
+ if(ipmij.ipmibattery != null && ipmij.ipmibattery.size()>0) {
+
+ JsonArrayBuilder ipmi_battery_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmibattery.size();j++) {
+ ipmiBatteryJson = ipmij.ipmibattery.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("batteryIdentifier", ipmiBatteryJson.batteryIdentifier);
+ ipmiBatteryJson.batteryType.encJsonValue(obj1, "batteryType");
+ ipmiBatteryJson.batteryVoltageLevel.encJsonValue(obj1, "batteryVoltageLevel");
+
+
+ ipmi_battery_array.add(obj1.build());
+ }
+
+ // obj.add("ipmiBatteryArray", ipmi_battery_array );
+ builder1.add("ipmiBatteryArray", ipmi_battery_array);
+
+
+ }
+
+
+ if(ipmij.ipmiNIC != null && ipmij.ipmiNIC.size()>0) {
+
+ JsonArrayBuilder ipmi_Nic_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiNIC.size();j++) {
+ ipmiNicJson = ipmij.ipmiNIC.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("nicIdentifier", ipmiNicJson.nic_Identifier);
+ ipmiNicJson.nic_Temperature.encJsonValue(obj1, "nicIdentifier");
+
+
+
+ ipmi_Nic_array.add(obj1.build());
+ }
+
+ // obj.add("ipmiNicArray", ipmi_Nic_array );
+ builder1.add("ipmiNicArray", ipmi_Nic_array);
+
+ }
+ if(ipmij.ipmiHSBP != null && ipmij.ipmiHSBP.size()>0) {
+
+ JsonArrayBuilder ipmi_HSBP_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiHSBP.size();j++) {
+ ipmiHsbpJson = ipmij.ipmiHSBP.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("hsbpIdentifier", ipmiHsbpJson.hsbpIdentifier);
+ ipmiHsbpJson.hsbpTemperature.encJsonValue(obj1, "hsbpTemperature");
+
+
+
+ ipmi_HSBP_array.add(obj1.build());
+ }
+
+ // obj.add("ipmiHsbpArray", ipmi_HSBP_array );
+ builder1.add("ipmiHsbpArray", ipmi_HSBP_array);
+
+ }
+
+
+ if(ipmij.ipmibaseboardTemperature!= null && ipmij.ipmibaseboardTemperature.size()>0) {
+
+ JsonArrayBuilder ipmi_baseboard_Temperature_array = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmibaseboardTemperature.size();j++) {
+ ipmiBaseBoardTempJson = ipmij.ipmibaseboardTemperature.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("baseboardTemperatureIdentifier", ipmiBaseBoardTempJson.baseboardTemperatureIdentifier);
+ ipmiBaseBoardTempJson.baseboardTemperature.encJsonValue(obj1, "baseboardTemperature");
+
+
+
+ ipmi_baseboard_Temperature_array.add(obj1.build());
+ }
+
+ // obj.add("ipmiBaseboardTemperatureArray", ipmi_baseboard_Temperature_array );
+ builder1.add("ipmiBaseboardTemperatureArray", ipmi_baseboard_Temperature_array);
+
+ }
+
+ if(ipmij.ipmiBaseboardvoltageResulator!= null && ipmij.ipmiBaseboardvoltageResulator.size()>0) {
+
+ JsonArrayBuilder ipmi_Baseboardvoltage_Resulator = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiBaseboardvoltageResulator.size();j++) {
+ ipmiBaseboardVoltageResultatorJson = ipmij.ipmiBaseboardvoltageResulator.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("baseboardVoltageRegulatorIdentifier",
+ ipmiBaseboardVoltageResultatorJson.baseboardVoltageRegulatorIdentifier);
+ ipmiBaseboardVoltageResultatorJson.voltageRegulatorTemperature.encJsonValue(obj1, "baseboardTemperature");
+
+
+
+ ipmi_Baseboardvoltage_Resulator.add(obj1.build());
+ }
+
+ // obj.add("ipmiBaseboardVoltageRegulatorArray", ipmi_Baseboardvoltage_Resulator );
+ builder1.add("ipmiBaseboardVoltageRegulatorArray", ipmi_Baseboardvoltage_Resulator);
+
+ }
+
+ if(ipmij.ipmiFan!= null && ipmij.ipmiFan.size()>0) {
+
+ JsonArrayBuilder ipmi_Fan = Json.createArrayBuilder();
+ for(int j=0; j<ipmij.ipmiFan.size();j++) {
+ ipmifanjson = ipmij.ipmiFan.get(j);
+ JsonObjectBuilder obj1 = Json.createObjectBuilder().add("fanIdentifier",
+ ipmifanjson.fanIdentifier);
+ ipmifanjson.fanSpeed.encJsonValue(obj1, "fanSpeed");
+
+
+
+ ipmi_Fan.add(obj1.build());
+ }
+
+ // obj.add("ipmiFanArray", ipmi_Fan );
+ builder1.add("ipmiFanArray", ipmi_Fan);
+
+ }
+
+
+
+
+
+
+ builder.add(obj.build());
+ }
+ //evelmeasmt.add("ipmi", builder) ;
+ evelmeasmt.add("ipmi", builder1) ;
+ }
/***************************************************************************/
/* Disk Use list. */
@@ -3426,6 +6163,24 @@ public class EvelScalingMeasurement extends EvelHeader { disk_use.timewritelast.encJsonValue(obj,"diskTimeWriteLast");
disk_use.timewritemax.encJsonValue(obj,"diskTimeWriteMax");
disk_use.timewritemin.encJsonValue(obj,"diskTimeWriteMin");
+
+ disk_use.diskTime.encJsonValue(obj, "diskTime");
+ disk_use.diskFlushRequests.encJsonValue(obj, "diskFlushRequests");
+ disk_use.diskFlushTime.encJsonValue(obj, "diskFlushTime");
+ disk_use.diskCommandsAvg.encJsonValue(obj, "diskCommandsAvg");
+ disk_use.diskReadCommandsAvg.encJsonValue(obj, "diskReadCommandsAvg");
+ disk_use.diskWriteCommandsAvg.encJsonValue(obj, "diskWriteCommandsAvg");
+ disk_use.diskCommandsAborted.encJsonValue(obj, "diskCommandsAborted");
+ disk_use.diskBusResets.encJsonValue(obj, "diskBusResets");
+ disk_use.diskTotalReadLatencyAvg.encJsonValue(obj, "diskTotalReadLatencyAvg");
+ disk_use.diskTotalWriteLatencyAvg.encJsonValue(obj, "diskTotalWriteLatencyAvg");
+
+ disk_use.diskWeightedIoTimeAvg.encJsonValue(obj, "diskWeightedIoTimeAvg");
+ disk_use.diskWeightedIoTimeLast.encJsonValue(obj, "diskWeightedIoTimeLast");
+ disk_use.diskWeightedIoTimeMax.encJsonValue(obj, "diskWeightedIoTimeMax");
+ disk_use.diskWeightedIoTimeMin.encJsonValue(obj, "diskWeightedIoTimeMin");
+
+
builder.add(obj.build());
}
@@ -3484,52 +6239,67 @@ public class EvelScalingMeasurement extends EvelHeader { {
JsonArrayBuilder builder = Json.createArrayBuilder();
for(int i=0;i<vnic_usage.size();i++) {
- vnic_use = vnic_usage.get(i);
+ nic_use = vnic_usage.get(i);
JsonObjectBuilder obj = Json.createObjectBuilder()
- .add( "vNicIdentifier", vnic_use.vnic_id)
- .add( "valuesAreSuspect",vnic_use.valuesaresuspect);
+ .add( "nicIdentifier", nic_use.vnic_id)
+ .add( "valuesAreSuspect",nic_use.valuesaresuspect);
/*********************************************************************/
/* Optional fields. */
/*********************************************************************/
- vnic_use.recvd_bcast_packets_acc.encJsonValue(obj,"receivedBroadcastPacketsAccumulated");
- vnic_use.recvd_bcast_packets_delta.encJsonValue(obj,"receivedBroadcastPacketsDelta");
- vnic_use.recvd_discarded_packets_acc.encJsonValue(obj,"receivedDiscardedPacketsAccumulated");
- vnic_use.recvd_discarded_packets_delta.encJsonValue(obj,"receivedDiscardedPacketsDelta");
- vnic_use.recvd_error_packets_acc.encJsonValue(obj,"receivedErrorPacketsAccumulated");
- vnic_use.recvd_error_packets_delta.encJsonValue(obj,"receivedErrorPacketsDelta");
-
- vnic_use.recvd_mcast_packets_acc.encJsonValue(obj,"receivedMulticastPacketsAccumulated");
- vnic_use.recvd_mcast_packets_delta.encJsonValue(obj,"receivedMulticastPacketsDelta");
- vnic_use.recvd_octets_acc.encJsonValue(obj,"receivedOctetsAccumulated");
- vnic_use.recvd_octets_delta.encJsonValue(obj,"receivedOctetsDelta");
-
- vnic_use.recvd_total_packets_acc.encJsonValue(obj,"receivedTotalPacketsAccumulated");
- vnic_use.recvd_total_packets_delta.encJsonValue(obj,"receivedTotalPacketsDelta");
- vnic_use.recvd_ucast_packets_acc.encJsonValue(obj,"receivedUnicastPacketsAccumulated");
- vnic_use.recvd_ucast_packets_delta.encJsonValue(obj,"receivedUnicastPacketsDelta");
-
- vnic_use.tx_bcast_packets_acc.encJsonValue(obj,"transmittedBroadcastPacketsAccumulated");
- vnic_use.tx_bcast_packets_delta.encJsonValue(obj,"transmittedBroadcastPacketsDelta");
- vnic_use.tx_discarded_packets_acc.encJsonValue(obj,"transmittedDiscardedPacketsAccumulated");
- vnic_use.tx_discarded_packets_delta.encJsonValue(obj,"transmittedDiscardedPacketsDelta");
-
- vnic_use.tx_error_packets_acc.encJsonValue(obj,"transmittedErrorPacketsAccumulated");
- vnic_use.tx_error_packets_delta.encJsonValue(obj,"transmittedErrorPacketsDelta");
- vnic_use.tx_mcast_packets_acc.encJsonValue(obj,"transmittedMulticastPacketsAccumulated");
- vnic_use.tx_mcast_packets_delta.encJsonValue(obj,"transmittedMulticastPacketsDelta");
-
- vnic_use.tx_octets_acc.encJsonValue(obj,"transmittedOctetsAccumulated");
- vnic_use.tx_octets_delta.encJsonValue(obj,"transmittedOctetsDelta");
- vnic_use.tx_total_packets_acc.encJsonValue(obj,"transmittedTotalPacketsAccumulated");
- vnic_use.tx_total_packets_delta.encJsonValue(obj,"transmittedTotalPacketsDelta");
- vnic_use.tx_ucast_packets_acc.encJsonValue(obj,"transmittedUnicastPacketsAccumulated");
- vnic_use.tx_ucast_packets_delta.encJsonValue(obj,"transmittedUnicastPacketsDelta");
+ nic_use.recvd_bcast_packets_acc.encJsonValue(obj,"receivedBroadcastPacketsAccumulated");
+ nic_use.recvd_bcast_packets_delta.encJsonValue(obj,"receivedBroadcastPacketsDelta");
+ nic_use.recvd_discarded_packets_acc.encJsonValue(obj,"receivedDiscardedPacketsAccumulated");
+ nic_use.recvd_discarded_packets_delta.encJsonValue(obj,"receivedDiscardedPacketsDelta");
+ nic_use.recvd_error_packets_acc.encJsonValue(obj,"receivedErrorPacketsAccumulated");
+ nic_use.recvd_error_packets_delta.encJsonValue(obj,"receivedErrorPacketsDelta");
+
+ nic_use.recvd_mcast_packets_acc.encJsonValue(obj,"receivedMulticastPacketsAccumulated");
+ nic_use.recvd_mcast_packets_delta.encJsonValue(obj,"receivedMulticastPacketsDelta");
+ nic_use.recvd_octets_acc.encJsonValue(obj,"receivedOctetsAccumulated");
+ nic_use.recvd_octets_delta.encJsonValue(obj,"receivedOctetsDelta");
+
+ nic_use.recvd_total_packets_acc.encJsonValue(obj,"receivedTotalPacketsAccumulated");
+ nic_use.recvd_total_packets_delta.encJsonValue(obj,"receivedTotalPacketsDelta");
+ nic_use.recvd_ucast_packets_acc.encJsonValue(obj,"receivedUnicastPacketsAccumulated");
+ nic_use.recvd_ucast_packets_delta.encJsonValue(obj,"receivedUnicastPacketsDelta");
+
+ nic_use.tx_bcast_packets_acc.encJsonValue(obj,"transmittedBroadcastPacketsAccumulated");
+ nic_use.tx_bcast_packets_delta.encJsonValue(obj,"transmittedBroadcastPacketsDelta");
+ nic_use.tx_discarded_packets_acc.encJsonValue(obj,"transmittedDiscardedPacketsAccumulated");
+ nic_use.tx_discarded_packets_delta.encJsonValue(obj,"transmittedDiscardedPacketsDelta");
+
+ nic_use.tx_error_packets_acc.encJsonValue(obj,"transmittedErrorPacketsAccumulated");
+ nic_use.tx_error_packets_delta.encJsonValue(obj,"transmittedErrorPacketsDelta");
+ nic_use.tx_mcast_packets_acc.encJsonValue(obj,"transmittedMulticastPacketsAccumulated");
+ nic_use.tx_mcast_packets_delta.encJsonValue(obj,"transmittedMulticastPacketsDelta");
+
+ nic_use.tx_octets_acc.encJsonValue(obj,"transmittedOctetsAccumulated");
+ nic_use.tx_octets_delta.encJsonValue(obj,"transmittedOctetsDelta");
+ nic_use.tx_total_packets_acc.encJsonValue(obj,"transmittedTotalPacketsAccumulated");
+ nic_use.tx_total_packets_delta.encJsonValue(obj,"transmittedTotalPacketsDelta");
+ nic_use.tx_ucast_packets_acc.encJsonValue(obj,"transmittedUnicastPacketsAccumulated");
+ nic_use.tx_ucast_packets_delta.encJsonValue(obj,"transmittedUnicastPacketsDelta");
+
+ //VES6.0 added fields 19July
+ nic_use.administrativeState.encJsonValue(obj, "administrativeState");
+ nic_use.administrativeState.encJsonValue(obj, "administrativeState");
+ nic_use.operationalState.encJsonValue(obj, "operationalState");
+ nic_use.receivedPercentDiscard.encJsonValue(obj, "receivedPercentDiscard");
+ nic_use.receivedPercentError.encJsonValue(obj, "receivedPercentError");
+ nic_use.receivedUtilization.encJsonValue(obj, "receivedUtilization");
+ nic_use.speed.encJsonValue(obj, "speed");
+ nic_use.transmittedPercentDiscard.encJsonValue(obj, "transmittedPercentDiscard");
+ nic_use.transmittedPercentError.encJsonValue(obj, "transmittedPercentError");
+ nic_use.transmittedUtilization.encJsonValue(obj, "transmittedUtilization");
+
+
+
builder.add(obj.build());
}
- evelmeasmt.add("vNicPerformanceArray", builder);
+ evelmeasmt.add("nicPerformanceArray", builder);
}
@@ -3543,9 +6313,9 @@ public class EvelScalingMeasurement extends EvelHeader { for(int i=0;i<mem_usage.size();i++) {
mem_use = mem_usage.get(i);
JsonObjectBuilder obj = Json.createObjectBuilder()
- .add( "memIdentifier", mem_use.id)
+ // .add( "memIdentifier", mem_use.id)
.add( "vmIdentifier", mem_use.vmid)
- .add( "percentUsage",mem_use.membuffsz);
+ .add( "percentMemoryUsage",mem_use.membuffsz);
mem_use.memcache.encJsonValue(obj,"memoryCached");
mem_use.memconfig.encJsonValue(obj,"memoryConfigured");
@@ -3556,37 +6326,38 @@ public class EvelScalingMeasurement extends EvelHeader { builder.add(obj.build());
}
- evelmeasmt.add("memUsageArray", builder);
+ evelmeasmt.add("memoryUsageArray", builder);
}
media_ports_in_use.encJsonValue(evelmeasmt, "numberOfMediaPortsInUse");
- vnfc_scaling_metric.encJsonValue(evelmeasmt, "vnfcScalingMetric");
+ vnfc_scaling_metric.encJsonValue(evelmeasmt, "nfcScalingMetric");
/***************************************************************************/
/* myerrors list. */
/***************************************************************************/
- if (errstat == true && myerrors != null)
- {
- evelmeasmt.add("receiveDiscards", myerrors.receive_discards);
- evelmeasmt.add("receivemyerrors", myerrors.receive_myerrors);
- evelmeasmt.add("transmitDiscards", myerrors.transmit_discards);
- evelmeasmt.add("transmitmyerrors", myerrors.transmit_myerrors);
- }
+ // if (errstat == true && myerrors != null)
+ // {
+ // evelmeasmt.add("receiveDiscards", myerrors.receive_discards);
+ // evelmeasmt.add("receivemyerrors", myerrors.receive_myerrors);
+ // evelmeasmt.add("transmitDiscards", myerrors.transmit_discards);
+ // evelmeasmt.add("transmitmyerrors", myerrors.transmit_myerrors);
+ // }
/***************************************************************************/
/* Feature Utilization list. */
/***************************************************************************/
if( feature_usage != null && feature_usage.size() > 0 )
{
- JsonArrayBuilder builder = Json.createArrayBuilder();
+ JsonObjectBuilder builder = Json.createObjectBuilder();
+ // JsonArrayBuilder builder = Json.createArrayBuilder();
for(int i=0;i<feature_usage.size();i++) {
feature_use = feature_usage.get(i);
- JsonObjectBuilder obj = Json.createObjectBuilder()
- .add( "featureIdentifier", feature_use.feature_id)
- .add( "featureUtilization", feature_use.feature_utilization);
+// JsonObjectBuilder obj = Json.createObjectBuilder()
+// .add( "featureIdentifier", feature_use.feature_id)
+// .add( "featureUtilization", feature_use.feature_utilization);
- builder.add(obj.build());
+ builder.add(feature_use.feature_id, feature_use.feature_utilization+"");
}
evelmeasmt.add("featureUsageArray", builder);
}
@@ -3597,14 +6368,15 @@ public class EvelScalingMeasurement extends EvelHeader { /***************************************************************************/
if( codec_usage != null && codec_usage.size() > 0 )
{
- JsonArrayBuilder builder = Json.createArrayBuilder();
+ //JsonObjectBuilder builder = Json.createObjectBuilder();
+ JsonArrayBuilder builder = Json.createArrayBuilder();
for(int i=0;i<codec_usage.size();i++) {
codec_use = codec_usage.get(i);
JsonObjectBuilder obj = Json.createObjectBuilder()
.add( "codecIdentifier", codec_use.codec_id)
.add( "numberInUse", codec_use.number_in_use);
- builder.add(obj.build());
+ builder.add(obj);
}
evelmeasmt.add("codecUsageArray", builder);
}
@@ -3620,16 +6392,19 @@ public class EvelScalingMeasurement extends EvelHeader { meas_group = additional_measurements.get(i);
JsonObjectBuilder obj = Json.createObjectBuilder()
.add( "name", meas_group.name);
- JsonArrayBuilder builder2 = Json.createArrayBuilder();
+ JsonObjectBuilder builder2 = Json.createObjectBuilder();
+
for(int j=0;j<meas_group.measurements.size();j++) {
custom_meas = meas_group.measurements.get(j);
- JsonObjectBuilder obj2 = Json.createObjectBuilder()
- .add("name",custom_meas.name)
- .add("value",custom_meas.value);
- builder2.add(obj2.build());
+// JsonObjectBuilder obj2 = Json.createObjectBuilder()
+// .add("name",custom_meas.name)
+// .add("value",custom_meas.value);
+ builder2.add(custom_meas.name, custom_meas.value);
}
- obj.add("arrayOfFields", builder2);
+ obj.add("hashMap", builder2);
builder.add(obj.build());
+
+
}
evelmeasmt.add("additionalMeasurements", builder);
}
@@ -3651,7 +6426,7 @@ public class EvelScalingMeasurement extends EvelHeader { /* Although optional, we always generate the version. Note that this */
/* closes the object, too. */
/***************************************************************************/
- evelmeasmt.add("measurementsForVfScalingVersion", version);
+ evelmeasmt.add("measurementFieldsVersion", version);
EVEL_EXIT();
@@ -3672,7 +6447,7 @@ public class EvelScalingMeasurement extends EvelHeader { JsonObject obj = Json.createObjectBuilder()
.add("event", Json.createObjectBuilder()
.add( "commonEventHeader",eventHeaderObject() )
- .add( "measurementsForVfScalingFields",evelScalingMeasurementObject() )
+ .add( "measurementFields",evelScalingMeasurementObject() )
).build();
EVEL_EXIT();
@@ -3682,4 +6457,4 @@ public class EvelScalingMeasurement extends EvelHeader { }
-}
+}
\ No newline at end of file |