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

Example 1 with PowerSetting

use of com.vmware.flowgate.openmanage.datamodel.PowerSetting 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 PowerSetting

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

the class OpenManageJobTest method getPowerSettings.

private CommonResult<PowerSetting> getPowerSettings() {
    CommonResult<PowerSetting> powerSettings = new CommonResult<PowerSetting>();
    List<PowerSetting> values = new ArrayList<PowerSetting>();
    PowerSetting power = new PowerSetting();
    power.setId(PowerSettingType.PowerUnit.getValue());
    power.setValue(PowerDisplayUnit.Watt.getValue());
    values.add(power);
    PowerSetting temperature = new PowerSetting();
    temperature.setId(PowerSettingType.TemperatureUnit.getValue());
    temperature.setValue(TemperatureDisplayUnit.Celsius.getValue());
    values.add(temperature);
    powerSettings.setValue(values);
    return powerSettings;
}