Add missing attribute in MetricDefinition in RSD 2.2

Change-Id: I179a2ee66d3906288cada0934adba0021653bda5
This commit is contained in:
Lin Yang 2019-05-24 16:27:03 -07:00
parent 5f1954f328
commit 52d13897d0
2 changed files with 236 additions and 212 deletions

View File

@ -15,126 +15,144 @@
from sushy.resources import base from sushy.resources import base
from rsd_lib import base as rsd_lib_base
from rsd_lib import utils as rsd_lib_utils from rsd_lib import utils as rsd_lib_utils
class WildcardsField(base.ListField): class IntelRackScaleField(base.CompositeField):
name = base.Field("Name")
"""This property shall contain a name for a Wildcard for a key"""
keys = base.Field("Keys") calculation_precision = base.Field("CalculationPrecision")
"""If the value is an empty string, then the server shall substitute every """This property specifies the precision of a calculated metric
current key. Each not empty key value shall be substituted for the (calculated metric shall be aligned to a value specified by This
wildcard property .
""" """
discrete_metric_type = base.Field("DiscreteMetricType")
"""This array property specifies possible values of a discrete metric."""
class OemField(base.CompositeField):
intel_rackscale = IntelRackScaleField("Intel_RackScale")
"""Intel Rack Scale Design specific properties."""
class CalculationParamsTypeCollectionField(base.ListField):
class CalculationParameterField(base.ListField):
source_metric = base.Field("SourceMetric") source_metric = base.Field("SourceMetric")
"""The metric property used as the input into the calculation""" """The metric property used as the input into the calculation."""
result_metric = base.Field("ResultMetric") result_metric = base.Field("ResultMetric")
"""The metric property used to store the results of the calculation""" """The metric property used to store the results of the calculation."""
class MetricDefinition(base.ResourceBase): class WildcardCollectionField(base.ListField):
name = base.Field('Name') name = base.Field("Name")
"""The CPUHealth metric definition name""" """The name of Wildcard."""
identity = base.Field('Id', required=True) values = base.Field("Values")
"""The CPUHealth metric definition identity string""" """An array of values to substitute for the wildcard."""
description = base.Field('Description')
"""The metric definition description"""
sensor_type = base.Field('SensorType') class MetricDefinition(rsd_lib_base.ResourceBase):
"""MetricDefinition resource class
A definition of a metric.
"""
implementation = base.Field("Implementation")
"""Specifies how the sensor is implemented."""
calculable = base.Field("Calculable")
"""Caculatability of this Metric."""
units = base.Field("Units")
"""Units of measure for this metric."""
data_type = base.Field("DataType")
"""The data type of the corresponding metric values."""
is_linear = base.Field("IsLinear", adapter=bool)
"""Indicates linear or non-linear values."""
metric_type = base.Field("MetricType")
"""Specifies the type of metric provided."""
wildcards = WildcardCollectionField("Wildcards")
"""Wildcards used to replace values in AppliesTo and Calculates metric
property arrays.
"""
metric_properties = base.Field("MetricProperties")
"""A collection of URI for the properties on which this metric definition
is defined.
"""
calculation_parameters = CalculationParamsTypeCollectionField(
"CalculationParameters"
)
"""Specifies the resource properties (metric) which are characterized by
this definition.
"""
physical_context = base.Field("PhysicalContext")
"""Specifies the physical context of the sensor."""
sensor_type = base.Field("SensorType")
"""This property represents the type of sensor that this resource """This property represents the type of sensor that this resource
represents represents.
""" """
metric_type = base.Field('MetricType') sensing_interval = base.Field("SensingInterval")
"""Specifies the type of metric provided"""
implementation = base.Field('Implementation')
"""The value of this property shall designate how the sensor is implemented
"""
sensing_interval = base.Field('SensingInterval')
"""This property specifies the time interval between when a metric or """This property specifies the time interval between when a metric or
sensor reading is updated sensor reading is updated.
""" """
physical_context = base.Field('PhysicalContext') discrete_values = base.Field("DiscreteValues")
"""Specifies the physical context of the sensor""" """This array property specifies possible values of a discrete metric."""
units = base.Field('Units') precision = base.Field("Precision", adapter=rsd_lib_utils.num_or_none)
"""Units of measure for this metric""" """Number of significant digits in the Reading described by
MetricProperties field.
"""
accuracy = base.Field("Accuracy", adapter=rsd_lib_utils.num_or_none)
"""Estimated percent error of measured vs. actual values."""
calibration = base.Field("Calibration", adapter=rsd_lib_utils.num_or_none)
"""Specifies the calibration offset added to the Reading to obtain an
accurate value.
"""
time_stamp_accuracy = base.Field("TimeStampAccuracy")
"""Accuracy of the timestamp."""
min_reading_range = base.Field( min_reading_range = base.Field(
'MinReadingRange', adapter=rsd_lib_utils.num_or_none) "MinReadingRange", adapter=rsd_lib_utils.num_or_none
"""Minimum value for Reading""" )
"""Minimum value for Reading."""
max_reading_range = base.Field( max_reading_range = base.Field(
'MaxReadingRange', adapter=rsd_lib_utils.num_or_none) "MaxReadingRange", adapter=rsd_lib_utils.num_or_none
"""Maximum value for Reading""" )
"""Maximum value for Reading."""
discrete_values = base.Field('DiscreteValues') calculation_algorithm = base.Field("CalculationAlgorithm")
"""This array property specifies possible values of a discrete metric"""
precision = base.Field('Precision', adapter=rsd_lib_utils.num_or_none)
"""Number of significant digits in the Reading described by
MetricProperties field
"""
calibration = base.Field('Calibration', adapter=rsd_lib_utils.num_or_none)
"""Specifies the calibration offset added to the Reading to obtain an
accurate value
"""
isLinear = base.Field('IsLinear', adapter=bool)
"""Indicates linear or non-linear values"""
calculable = base.Field('Calculable')
"""The value shall define the caculatability of this metric"""
data_type = base.Field('DataType')
"""The data type of the corresponding metric values"""
accuracy = base.Field('Accuracy', adapter=rsd_lib_utils.num_or_none)
"""Estimated percent error of measured vs. actual values"""
time_stamp_accuracy = base.Field('TimeStampAccuracy')
"""Accuracy of the timestamp"""
calculation_time_interval = base.Field('CalculationTimeInterval')
"""This property specifies the time interval over which a calculated
metric algorithm is performed
"""
calculation_algorithm = base.Field('CalculationAlgorithm')
"""This property specifies the calculation which is performed on a source """This property specifies the calculation which is performed on a source
metric to obtain the metric being defined metric to obtain the metric being defined.
""" """
calculation_parameters = CalculationParameterField('CalculationParameters') calculation_time_interval = base.Field("CalculationTimeInterval")
"""Specifies the resource properties (metric) which are characterized by """This property specifies the time interval over which a calculated
this definition metric algorithm is performed.
""" """
wildcards = WildcardsField("Wildcards") oem = OemField("Oem")
"""The property shall contain an array of wildcards and their replacements """Oem specific properties."""
strings, which are to appliced to the MetricProperties array property
"""
metric_properties = base.Field('MetricProperties')
"""A collection of URI for the properties on which this metric definition
is defined
"""
class MetricDefinitionCollection(base.ResourceCollectionBase): class MetricDefinitionCollection(rsd_lib_base.ResourceCollectionBase):
@property @property
def _resource_type(self): def _resource_type(self):
return MetricDefinition return MetricDefinition

View File

@ -21,113 +21,108 @@ from rsd_lib.resources.v2_2.telemetry import metric_definition
class MetricDefinitionTestCase(testtools.TestCase): class MetricDefinitionTestCase(testtools.TestCase):
def setUp(self): def setUp(self):
super(MetricDefinitionTestCase, self).setUp() super(MetricDefinitionTestCase, self).setUp()
self.conn = mock.Mock() self.conn = mock.Mock()
with open('rsd_lib/tests/unit/json_samples/v2_2/' with open(
'metric_definition.json', 'r') as f: "rsd_lib/tests/unit/json_samples/v2_2/" "metric_definition.json",
"r",
) as f:
self.conn.get.return_value.json.return_value = json.loads(f.read()) self.conn.get.return_value.json.return_value = json.loads(f.read())
self.metric_definition_inst = metric_definition.MetricDefinition( self.metric_definition_inst = metric_definition.MetricDefinition(
self.conn, self.conn,
'/redfish/v1/TelemetryService/MetricDefinitions/1-md-6', "/redfish/v1/TelemetryService/MetricDefinitions/1-md-6",
redfish_version='1.1.0') redfish_version="1.1.0",
)
def test__parse_attributes(self): def test__parse_attributes(self):
self.metric_definition_inst._parse_attributes() self.metric_definition_inst._parse_attributes()
self.assertEqual('1.1.0', self.assertEqual("1.1.0", self.metric_definition_inst.redfish_version)
self.metric_definition_inst.redfish_version) self.assertEqual("memoryTemperature", self.metric_definition_inst.name)
self.assertEqual('memoryTemperature', self.metric_definition_inst.name) self.assertEqual("1-md-6", self.metric_definition_inst.identity)
self.assertEqual('1-md-6', self.metric_definition_inst.identity)
self.assertEqual('Metric Definition description',
self.metric_definition_inst.description)
self.assertEqual('Numeric',
self.metric_definition_inst.metric_type)
self.assertEqual('Temperature',
self.metric_definition_inst.sensor_type)
self.assertEqual('PhysicalSensor',
self.metric_definition_inst.implementation)
self.assertEqual('10.0s',
self.metric_definition_inst.sensing_interval)
self.assertEqual('SystemBoard',
self.metric_definition_inst.physical_context)
self.assertEqual('Celsius',
self.metric_definition_inst.units)
self.assertEqual( self.assertEqual(
None, self.metric_definition_inst.min_reading_range) "Metric Definition description",
self.metric_definition_inst.description,
)
self.assertEqual("Numeric", self.metric_definition_inst.metric_type)
self.assertEqual( self.assertEqual(
None, self.metric_definition_inst.max_reading_range) "Temperature", self.metric_definition_inst.sensor_type
)
self.assertEqual(
"PhysicalSensor", self.metric_definition_inst.implementation
)
self.assertEqual("10.0s", self.metric_definition_inst.sensing_interval)
self.assertEqual(
"SystemBoard", self.metric_definition_inst.physical_context
)
self.assertEqual("Celsius", self.metric_definition_inst.units)
self.assertEqual(None, self.metric_definition_inst.min_reading_range)
self.assertEqual(None, self.metric_definition_inst.max_reading_range)
self.assertEqual([], self.metric_definition_inst.discrete_values) self.assertEqual([], self.metric_definition_inst.discrete_values)
self.assertEqual(None, self.metric_definition_inst.precision)
self.assertEqual(None, self.metric_definition_inst.calibration)
self.assertEqual(True, self.metric_definition_inst.is_linear)
self.assertEqual(None, self.metric_definition_inst.calculable)
self.assertEqual(None, self.metric_definition_inst.data_type)
self.assertEqual(None, self.metric_definition_inst.accuracy)
self.assertEqual(None, self.metric_definition_inst.time_stamp_accuracy)
self.assertEqual( self.assertEqual(
None, self.metric_definition_inst.precision) None, self.metric_definition_inst.calculation_time_interval
)
self.assertEqual( self.assertEqual(
None, self.metric_definition_inst.calibration) None, self.metric_definition_inst.calculation_algorithm
)
self.assertEqual( self.assertEqual(
True, self.metric_definition_inst.isLinear) [], self.metric_definition_inst.calculation_parameters
self.assertEqual( )
None, self.metric_definition_inst.calculable) self.assertEqual([], self.metric_definition_inst.wildcards)
self.assertEqual(
None, self.metric_definition_inst.data_type)
self.assertEqual(
None, self.metric_definition_inst.accuracy)
self.assertEqual(
None, self.metric_definition_inst.time_stamp_accuracy)
self.assertEqual(
None, self.metric_definition_inst.calculation_time_interval)
self.assertEqual(
None, self.metric_definition_inst.calculation_algorithm)
self.assertEqual(
[], self.metric_definition_inst.calculation_parameters)
self.assertEqual(
[], self.metric_definition_inst.wildcards)
with open('rsd_lib/tests/unit/json_samples/v2_2/' with open(
'cpu_bandwidth_metric_def.json', 'r') as f: "rsd_lib/tests/unit/json_samples/v2_2/"
"cpu_bandwidth_metric_def.json",
"r",
) as f:
self.conn.get.return_value.json.return_value = json.loads(f.read()) self.conn.get.return_value.json.return_value = json.loads(f.read())
self.metric_definition_inst.refresh() self.metric_definition_inst.refresh()
self.assertEqual('1.1.0', self.assertEqual("1.1.0", self.metric_definition_inst.redfish_version)
self.metric_definition_inst.redfish_version)
self.assertEqual('CPU Bandwidth type',
self.metric_definition_inst.name)
self.assertEqual('CPUBandwidth',
self.metric_definition_inst.identity)
self.assertEqual('Numeric',
self.metric_definition_inst.metric_type)
self.assertEqual('DigitalMeter',
self.metric_definition_inst.implementation)
self.assertEqual('PT1S',
self.metric_definition_inst.sensing_interval)
self.assertEqual('CPU',
self.metric_definition_inst.physical_context)
self.assertEqual('%', self.metric_definition_inst.units)
self.assertEqual( self.assertEqual(
0, self.metric_definition_inst.min_reading_range) "CPU Bandwidth type", self.metric_definition_inst.name
)
self.assertEqual("CPUBandwidth", self.metric_definition_inst.identity)
self.assertEqual("Numeric", self.metric_definition_inst.metric_type)
self.assertEqual( self.assertEqual(
100, self.metric_definition_inst.max_reading_range) "DigitalMeter", self.metric_definition_inst.implementation
)
self.assertEqual("PT1S", self.metric_definition_inst.sensing_interval)
self.assertEqual("CPU", self.metric_definition_inst.physical_context)
self.assertEqual("%", self.metric_definition_inst.units)
self.assertEqual(0, self.metric_definition_inst.min_reading_range)
self.assertEqual(100, self.metric_definition_inst.max_reading_range)
with open('rsd_lib/tests/unit/json_samples/v2_2/' with open(
'cpu_health_metric_def.json', 'r') as f: "rsd_lib/tests/unit/json_samples/v2_2/"
"cpu_health_metric_def.json",
"r",
) as f:
self.conn.get.return_value.json.return_value = json.loads(f.read()) self.conn.get.return_value.json.return_value = json.loads(f.read())
self.metric_definition_inst.refresh() self.metric_definition_inst.refresh()
self.assertEqual('1.1.0', self.assertEqual("1.1.0", self.metric_definition_inst.redfish_version)
self.metric_definition_inst.redfish_version) self.assertEqual(
self.assertEqual('CPU1 IPMI Health Sensor', "CPU1 IPMI Health Sensor", self.metric_definition_inst.name
self.metric_definition_inst.name) )
self.assertEqual('CPUHealth1', self.assertEqual("CPUHealth1", self.metric_definition_inst.identity)
self.metric_definition_inst.identity) self.assertEqual("Discrete", self.metric_definition_inst.metric_type)
self.assertEqual('Discrete', self.assertEqual(
self.metric_definition_inst.metric_type) "PhysicalSensor", self.metric_definition_inst.sensor_type
self.assertEqual('PhysicalSensor', )
self.metric_definition_inst.sensor_type) self.assertEqual(
self.assertEqual('PhysicalSensor', "PhysicalSensor", self.metric_definition_inst.implementation
self.metric_definition_inst.implementation) )
self.assertEqual('PT1S', self.assertEqual("PT1S", self.metric_definition_inst.sensing_interval)
self.metric_definition_inst.sensing_interval) self.assertEqual("CPU", self.metric_definition_inst.physical_context)
self.assertEqual('CPU',
self.metric_definition_inst.physical_context)
expected = [ expected = [
"OK", "OK",
@ -143,89 +138,100 @@ class MetricDefinitionTestCase(testtools.TestCase):
"Terminator Presence Detected", "Terminator Presence Detected",
"Processor Throttled", "Processor Throttled",
"Machine Check Exception", "Machine Check Exception",
"Correctable Machine Check Error" "Correctable Machine Check Error",
] ]
self.assertEqual(expected, self.assertEqual(expected, self.metric_definition_inst.discrete_values)
self.metric_definition_inst.discrete_values)
with open('rsd_lib/tests/unit/json_samples/v2_2/' with open(
'cpu_temperature_metric_def.json', 'r') as f: "rsd_lib/tests/unit/json_samples/v2_2/"
"cpu_temperature_metric_def.json",
"r",
) as f:
self.conn.get.return_value.json.return_value = json.loads(f.read()) self.conn.get.return_value.json.return_value = json.loads(f.read())
self.metric_definition_inst.refresh() self.metric_definition_inst.refresh()
self.assertEqual('1.1.0', self.assertEqual("1.1.0", self.metric_definition_inst.redfish_version)
self.metric_definition_inst.redfish_version)
self.assertEqual('Temperature MetricDefinition',
self.metric_definition_inst.name)
self.assertEqual('TEMP1',
self.metric_definition_inst.identity)
self.assertEqual('Numeric',
self.metric_definition_inst.metric_type)
self.assertEqual('Temperature',
self.metric_definition_inst.sensor_type)
self.assertEqual('Physical',
self.metric_definition_inst.implementation)
self.assertEqual('PT1S',
self.metric_definition_inst.sensing_interval)
self.assertEqual('CPU',
self.metric_definition_inst.physical_context)
self.assertEqual('Cel', self.metric_definition_inst.units)
self.assertEqual( self.assertEqual(
0, self.metric_definition_inst.min_reading_range) "Temperature MetricDefinition", self.metric_definition_inst.name
)
self.assertEqual("TEMP1", self.metric_definition_inst.identity)
self.assertEqual("Numeric", self.metric_definition_inst.metric_type)
self.assertEqual( self.assertEqual(
80, self.metric_definition_inst.max_reading_range) "Temperature", self.metric_definition_inst.sensor_type
)
self.assertEqual(
"Physical", self.metric_definition_inst.implementation
)
self.assertEqual("PT1S", self.metric_definition_inst.sensing_interval)
self.assertEqual("CPU", self.metric_definition_inst.physical_context)
self.assertEqual("Cel", self.metric_definition_inst.units)
self.assertEqual(0, self.metric_definition_inst.min_reading_range)
self.assertEqual(80, self.metric_definition_inst.max_reading_range)
self.assertEqual(1, self.metric_definition_inst.precision) self.assertEqual(1, self.metric_definition_inst.precision)
self.assertEqual(2, self.metric_definition_inst.calibration) self.assertEqual(2, self.metric_definition_inst.calibration)
class MetricDefinitionsCollectionTestCase(testtools.TestCase): class MetricDefinitionsCollectionTestCase(testtools.TestCase):
def setUp(self): def setUp(self):
super(MetricDefinitionsCollectionTestCase, self).setUp() super(MetricDefinitionsCollectionTestCase, self).setUp()
self.conn = mock.Mock() self.conn = mock.Mock()
with open('rsd_lib/tests/unit/json_samples/v2_2/' with open(
'metric_definition_collection.json', 'r') as f: "rsd_lib/tests/unit/json_samples/v2_2/"
"metric_definition_collection.json",
"r",
) as f:
self.conn.get.return_value.json.return_value = json.loads(f.read()) self.conn.get.return_value.json.return_value = json.loads(f.read())
self.metric_def_col = metric_definition.MetricDefinitionCollection( self.metric_def_col = metric_definition.MetricDefinitionCollection(
self.conn, '/redfish/v1/TelemetryService/MetricDefinitions', self.conn,
redfish_version='1.1.0') "/redfish/v1/TelemetryService/MetricDefinitions",
redfish_version="1.1.0",
)
def test__parse_attributes(self): def test__parse_attributes(self):
self.metric_def_col._parse_attributes() self.metric_def_col._parse_attributes()
self.assertEqual('1.1.0', self.metric_def_col.redfish_version) self.assertEqual("1.1.0", self.metric_def_col.redfish_version)
self.assertEqual( self.assertEqual(
('/redfish/v1/TelemetryService/MetricDefinitions/CPUTemperature', (
'/redfish/v1/TelemetryService/MetricDefinitions/CPUHealth', "/redfish/v1/TelemetryService/MetricDefinitions/"
'/redfish/v1/TelemetryService/MetricDefinitions/CPUBandwidth'), "CPUTemperature",
self.metric_def_col.members_identities) "/redfish/v1/TelemetryService/MetricDefinitions/CPUHealth",
"/redfish/v1/TelemetryService/MetricDefinitions/CPUBandwidth",
),
self.metric_def_col.members_identities,
)
@mock.patch.object(metric_definition, 'MetricDefinition', autospec=True) @mock.patch.object(metric_definition, "MetricDefinition", autospec=True)
def test_get_member(self, mock_metric_definition): def test_get_member(self, mock_metric_definition):
self.metric_def_col.get_member( self.metric_def_col.get_member(
'/redfish/v1/TelemetryService/MetricDefinitions/CPUTemperature') "/redfish/v1/TelemetryService/MetricDefinitions/CPUTemperature"
)
mock_metric_definition.assert_called_once_with( mock_metric_definition.assert_called_once_with(
self.metric_def_col._conn, self.metric_def_col._conn,
'/redfish/v1/TelemetryService/MetricDefinitions/CPUTemperature', "/redfish/v1/TelemetryService/MetricDefinitions/CPUTemperature",
redfish_version=self.metric_def_col.redfish_version) redfish_version=self.metric_def_col.redfish_version,
)
@mock.patch.object(metric_definition, 'MetricDefinition', autospec=True) @mock.patch.object(metric_definition, "MetricDefinition", autospec=True)
def test_get_members(self, mock_metric_definition): def test_get_members(self, mock_metric_definition):
members = self.metric_def_col.get_members() members = self.metric_def_col.get_members()
calls = [ calls = [
mock.call( mock.call(
self.metric_def_col._conn, self.metric_def_col._conn,
'/redfish/v1/TelemetryService/MetricDefinitions/' "/redfish/v1/TelemetryService/MetricDefinitions/"
'CPUTemperature', "CPUTemperature",
redfish_version=self.metric_def_col.redfish_version), redfish_version=self.metric_def_col.redfish_version,
),
mock.call( mock.call(
self.metric_def_col._conn, self.metric_def_col._conn,
'/redfish/v1/TelemetryService/MetricDefinitions/CPUHealth', "/redfish/v1/TelemetryService/MetricDefinitions/CPUHealth",
redfish_version=self.metric_def_col.redfish_version), redfish_version=self.metric_def_col.redfish_version,
),
mock.call( mock.call(
self.metric_def_col._conn, self.metric_def_col._conn,
'/redfish/v1/TelemetryService/MetricDefinitions/CPUBandwidth', "/redfish/v1/TelemetryService/MetricDefinitions/CPUBandwidth",
redfish_version=self.metric_def_col.redfish_version) redfish_version=self.metric_def_col.redfish_version,
),
] ]
mock_metric_definition.assert_has_calls(calls) mock_metric_definition.assert_has_calls(calls)
self.assertIsInstance(members, list) self.assertIsInstance(members, list)