Examples with DevicePower com.vmware.flowgate.openmanage.datamodel.DevicePower used on opensource projects

Example 1 with DevicePower

use of com.vmware.flowgate.openmanage.datamodel.DevicePower in project flowgate by vmware.

the class OpenManageJobService method getMetricsData.

private Map<String, ValueUnit> getMetricsData(String deviceId, OpenManageAPIClient client, Plugin powerManage) {
    DevicePower powerMetricsData = client.getDevicePowerMetrics(deviceId);
    long currentTime = 0;
    Map<String, ValueUnit> metricNameAndValueUnitMap = new HashMap<String, ValueUnit>();
    // Power metrics data from the Openmanage base API
    if (powerMetricsData != null && CIM.equals(powerMetricsData.getDateFormat())) {
        String power = powerMetricsData.getPower();
        if (!NULLVALUE.equals(power)) {
            ValueUnit instantPower = new ValueUnit();
            currentTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getInstantaneousHeadroomTimeStamp());
            instantPower.setKey(MetricName.SERVER_POWER);
            instantPower.setTime(currentTime);
            instantPower.setUnit(MetricUnit.kW.name());
            instantPower.setValueNum(instantPower.translateUnit(Double.valueOf(power), metricUnitMap.get(powerMetricsData.getPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_POWER, instantPower);
        }
        long sinceTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getSince());
        String energyConsumption = powerMetricsData.getSystemEnergyConsumption();
        if (!NULLVALUE.equals(energyConsumption)) {
            long systemEnergyConsumptionTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getSystemEnergyConsumptionTimeStamp());
            ValueUnit systemEnergyConsumption = new ValueUnit();
            systemEnergyConsumption.setTime(systemEnergyConsumptionTime);
            systemEnergyConsumption.setExtraidentifier(String.valueOf(sinceTime));
            systemEnergyConsumption.setKey(MetricName.SERVER_ENERGY_CONSUMPTION);
            systemEnergyConsumption.setUnit(MetricUnit.kWh.name());
            systemEnergyConsumption.setValueNum(systemEnergyConsumption.translateUnit(Double.valueOf(energyConsumption), metricUnitMap.get(powerMetricsData.getSystemEnergyConsumptionUnit()), MetricUnit.kWh));
            metricNameAndValueUnitMap.put(MetricName.SERVER_ENERGY_CONSUMPTION, systemEnergyConsumption);
        }
        String avgValue = powerMetricsData.getAvgPower();
        if (!NULLVALUE.equals(avgValue)) {
            ValueUnit avgPower = new ValueUnit();
            avgPower.setTime(currentTime);
            avgPower.setExtraidentifier(String.valueOf(sinceTime));
            avgPower.setKey(MetricName.SERVER_AVERAGE_USED_POWER);
            avgPower.setUnit(MetricUnit.kW.name());
            avgPower.setValueNum(avgPower.translateUnit(Double.valueOf(avgValue), metricUnitMap.get(powerMetricsData.getAvgPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_AVERAGE_USED_POWER, avgPower);
        }
        String peakValue = powerMetricsData.getPeakPower();
        if (!NULLVALUE.equals(peakValue)) {
            ValueUnit peakPower = new ValueUnit();
            peakPower.setTime(currentTime);
            long peakPowerTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getPeakPowerTimeStamp());
            String sinceAndPeakTime = String.valueOf(sinceTime) + FlowgateConstant.SEPARATOR + String.valueOf(peakPowerTime);
            // Record the since time and peak power time, for example  1612417403074_FIELDSPLIT_1612415606985
            peakPower.setExtraidentifier(sinceAndPeakTime);
            peakPower.setKey(MetricName.SERVER_PEAK_USED_POWER);
            peakPower.setUnit(MetricUnit.kW.name());
            peakPower.setValueNum(peakPower.translateUnit(Double.valueOf(peakValue), metricUnitMap.get(powerMetricsData.getPeakPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_PEAK_USED_POWER, peakPower);
        }
        String minimumValue = powerMetricsData.getMinimumPower();
        if (!NULLVALUE.equals(minimumValue)) {
            ValueUnit minimumPower = new ValueUnit();
            minimumPower.setTime(currentTime);
            long minimumTime = WormholeDateFormat.cimDateToMilliseconds(powerMetricsData.getMinimumPowerTimeStamp());
            String sinceAndMinimum = String.valueOf(sinceTime) + FlowgateConstant.SEPARATOR + String.valueOf(minimumTime);
            minimumPower.setExtraidentifier(sinceAndMinimum);
            minimumPower.setKey(MetricName.SERVER_MINIMUM_USED_POWER);
            minimumPower.setUnit(MetricUnit.kW.name());
            minimumPower.setValueNum(minimumPower.translateUnit(Double.valueOf(minimumValue), metricUnitMap.get(powerMetricsData.getPeakPowerUnit()), MetricUnit.kW));
            metricNameAndValueUnitMap.put(MetricName.SERVER_MINIMUM_USED_POWER, minimumPower);
        }
    }
    // Temperature metrics data from the Openmanage base API
    DeviceTemperature temperatureMetrics = client.getDeviceTemperatureMetrics(deviceId);
    if (temperatureMetrics != null && CIM.equals(temperatureMetrics.getDateFormat())) {
        String temperatureValue = temperatureMetrics.getInstantaneousTemperature();
        if (!NULLVALUE.equals(temperatureValue)) {
            ValueUnit temperature = new ValueUnit();
            temperature.setKey(MetricName.SERVER_TEMPERATURE);
            temperature.setTime(currentTime);
            temperature.setUnit(MetricUnit.C.name());
            temperature.setValueNum(temperature.translateUnit(Double.valueOf(temperatureValue), metricUnitMap.get(temperatureMetrics.getInstantaneousTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_TEMPERATURE, temperature);
        }
        long startTime = WormholeDateFormat.cimDateToMilliseconds(temperatureMetrics.getStartTime());
        String avgValue = temperatureMetrics.getAvgTemperature();
        if (!NULLVALUE.equals(avgValue)) {
            ValueUnit avgTemperature = new ValueUnit();
            avgTemperature.setKey(MetricName.SERVER_AVERAGE_TEMPERATURE);
            avgTemperature.setExtraidentifier(String.valueOf(startTime));
            avgTemperature.setTime(currentTime);
            avgTemperature.setUnit(MetricUnit.C.name());
            avgTemperature.setValueNum(avgTemperature.translateUnit(Double.valueOf(avgValue), metricUnitMap.get(temperatureMetrics.getAvgTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_AVERAGE_TEMPERATURE, avgTemperature);
        }
        String peakValue = temperatureMetrics.getPeakTemperature();
        if (!NULLVALUE.equals(peakValue)) {
            ValueUnit peakTemperature = new ValueUnit();
            peakTemperature.setKey(MetricName.SERVER_PEAK_TEMPERATURE);
            long peakTime = WormholeDateFormat.cimDateToMilliseconds(temperatureMetrics.getPeakTemperatureTimeStamp());
            String startAndPeakTime = String.valueOf(startTime) + FlowgateConstant.SEPARATOR + String.valueOf(peakTime);
            peakTemperature.setExtraidentifier(startAndPeakTime);
            peakTemperature.setTime(currentTime);
            peakTemperature.setUnit(MetricUnit.C.name());
            peakTemperature.setValueNum(peakTemperature.translateUnit(Double.valueOf(peakValue), metricUnitMap.get(temperatureMetrics.getPeakTemperatureUnit()), MetricUnit.C));
            metricNameAndValueUnitMap.put(MetricName.SERVER_PEAK_TEMPERATURE, peakTemperature);
        }
    }
    // get metrics form power Manage plugin
    if (powerManage != null && powerManagerEnable) {
        String pluginId = powerManage.getId();
        PowerManageMetricsRequestBody body = new PowerManageMetricsRequestBody();
        body.setPluginId(pluginId);
        body.setEntityType(EntityType.Device.getValue());
        body.setEntityId(Integer.valueOf(deviceId));
        List<Integer> metricTypes = new ArrayList<Integer>();
        metricTypes.add(MetricType.INSTANT_POWER.getValue());
        // Inlet temperature
        metricTypes.add(MetricType.INSTANT_TEMP.getValue());
        body.setMetricTypes(metricTypes);
        body.setDuration(Duration.Recent.getValue());
        body.setSortOrder(SortOrder.Ascending.getValue());
        DeviceMetricsResult metrics = null;
        try {
            metrics = client.getMetricsFromPowerManage(body);
        } catch (HttpClientErrorException e) {
            logger.error("Not found any metrics data.", e);
            return metricNameAndValueUnitMap;
        }
        List<DeviceMetric> metricValues = metrics.getValue();
        if (metricValues.isEmpty()) {
            return metricNameAndValueUnitMap;
        }
        Map<Integer, String> metricTypeMap = new HashMap<Integer, String>();
        metricTypeMap.put(MetricType.INSTANT_POWER.getValue(), MetricName.SERVER_TOTAL_POWER);
        metricTypeMap.put(MetricType.INSTANT_TEMP.getValue(), MetricName.SERVER_FRONT_TEMPERATURE);
        CommonResult<PowerSetting> powerSettings = client.getCommonResult(PowerSetting.class);
        Map<Integer, Integer> powerSettingTypeAndValueMap = new HashMap<Integer, Integer>();
        for (PowerSetting powerSetting : powerSettings.getValue()) {
            powerSettingTypeAndValueMap.put(powerSetting.getId(), powerSetting.getValue());
        }
        for (DeviceMetric metric : metricValues) {
            if (MetricType.INSTANT_POWER.getValue() == metric.getType()) {
                ValueUnit instantPower = new ValueUnit();
                instantPower.setKey(MetricName.SERVER_POWER);
                instantPower.setTime(currentTime);
                instantPower.setUnit(MetricUnit.kW.name());
                int unitValue = powerSettingTypeAndValueMap.get(PowerSettingType.PowerUnit.getValue());
                // PowerUnit1 : watt
                // PowerUnit2 : BtuPerHr
                MetricUnit powerSourceUnit = metricUnitMap.get(PowerSettingType.PowerUnit.name() + unitValue);
                instantPower.setValueNum(instantPower.translateUnit(metric.getValue(), powerSourceUnit, MetricUnit.kW));
                metricNameAndValueUnitMap.put(MetricName.SERVER_POWER, instantPower);
            } else if (MetricType.INSTANT_TEMP.getValue() == metric.getType()) {
                ValueUnit inletTemperature = new ValueUnit();
                inletTemperature.setKey(MetricName.SERVER_FRONT_TEMPERATURE);
                inletTemperature.setTime(currentTime);
                inletTemperature.setUnit(MetricUnit.C.name());
                int unitValue = powerSettingTypeAndValueMap.get(PowerSettingType.TemperatureUnit.getValue());
                MetricUnit temperatureSourceUnit = metricUnitMap.get(PowerSettingType.TemperatureUnit.name() + unitValue);
                inletTemperature.setValueNum(inletTemperature.translateUnit(metric.getValue(), temperatureSourceUnit, MetricUnit.C));
                metricNameAndValueUnitMap.put(MetricName.SERVER_FRONT_TEMPERATURE, inletTemperature);
            }
        }
    }
    return metricNameAndValueUnitMap;
}

Example 2 with DevicePower

use of com.vmware.flowgate.openmanage.datamodel.DevicePower in project flowgate by vmware.

the class OpenManageJobTest method getPowerMetricsData.

private DevicePower getPowerMetricsData() {
    DevicePower devicePower = new DevicePower();
    devicePower.setDateFormat("CIM");
    devicePower.setAvgPower("74");
    devicePower.setPower("72");
    devicePower.setPeakPower("80");
    devicePower.setMinimumPower("70");
    devicePower.setSystemEnergyConsumption("800");
    devicePower.setAvgPowerUnit(OpenManageJobService.OpenmanagePowerUnit);
    devicePower.setPeakPowerUnit(OpenManageJobService.OpenmanagePowerUnit);
    devicePower.setPowerUnit(OpenManageJobService.OpenmanagePowerUnit);
    devicePower.setMinimumPowerUnit(OpenManageJobService.OpenmanagePowerUnit);
    devicePower.setSystemEnergyConsumptionUnit(OpenManageJobService.systemEnergyConsumptionUnit);
    devicePower.setPeakPowerTimeStamp("20210125105010.404804-360");
    devicePower.setMinimumPowerTimeStamp("20210126105010.404804-360");
    devicePower.setInstantaneousHeadroomTimeStamp("20210127105010.404804-360");
    devicePower.setSince("20210117105010.404804-360");
    devicePower.setSystemEnergyConsumptionTimeStamp("20210127105010.404804-360");
    return devicePower;
}

Example 3 with DevicePower

use of com.vmware.flowgate.openmanage.datamodel.DevicePower in project flowgate by vmware.

the class OpenManageJobTest method getMetricDatasTestNA.

@Test
public void getMetricDatasTestNA() {
    Mockito.when(this.openManageAPIClient.getCommonResult(Plugin.class)).thenReturn(getCommonResult());
    DevicePower powerMetrics = getPowerMetricsData();
    powerMetrics.setMinimumPower("N/A");
    Mockito.when(this.openManageAPIClient.getDevicePowerMetrics("10074")).thenReturn(powerMetrics);
    Mockito.when(this.openManageAPIClient.getDeviceTemperatureMetrics("10074")).thenReturn(getDeviceTemperature());
    Mockito.when(this.openManageAPIClient.getMetricsFromPowerManage(any(PowerManageMetricsRequestBody.class))).thenReturn(getDeviceMetricsResult());
    Mockito.when(this.openManageAPIClient.getCommonResult(PowerSetting.class)).thenReturn(getPowerSettings());
    FacilitySoftwareConfig config = new FacilitySoftwareConfig();
    config.setId(createAsset().getAssetSource());
    List<RealTimeData> metricDatas = openmanageJobService.getMetricDatas(config, openManageAPIClient);
    for (RealTimeData data : metricDatas) {
        if ("assetid1611766210404".equals(data.getId())) {
            // power metrics
            List<ValueUnit> values = data.getValues();
            for (ValueUnit value : values) {
                switch(value.getKey()) {
                    case MetricName.SERVER_AVERAGE_USED_POWER:
                        TestCase.assertEquals(0.074, value.getValueNum());
                        break;
                    // use powerManager value to override it
                    case MetricName.SERVER_POWER:
                        TestCase.assertEquals(0.072, value.getValueNum());
                        break;
                    case MetricName.SERVER_MINIMUM_USED_POWER:
                        TestCase.fail("Should not contain the " + MetricName.SERVER_MINIMUM_USED_POWER);
                        break;
                    case MetricName.SERVER_PEAK_USED_POWER:
                        TestCase.assertEquals(0.08, value.getValueNum());
                        break;
                    case MetricName.SERVER_ENERGY_CONSUMPTION:
                        TestCase.assertEquals(800.0, value.getValueNum());
                        break;
                    case MetricName.SERVER_AVERAGE_TEMPERATURE:
                        TestCase.assertEquals(22.0, value.getValueNum());
                        break;
                    case MetricName.SERVER_TEMPERATURE:
                        TestCase.assertEquals(24.0, value.getValueNum());
                        break;
                    case MetricName.SERVER_PEAK_TEMPERATURE:
                        TestCase.assertEquals(30.0, value.getValueNum());
                        break;
                    case MetricName.SERVER_FRONT_TEMPERATURE:
                        TestCase.assertEquals(24.0, value.getValueNum());
                        break;
                    default:
                        TestCase.fail();
                        break;
                }
            }
        } else {
            TestCase.fail();
        }
    }
}