Property characteristics
Properties are classified as being either writable or read-only from the perspective of an API client application.
Writable properties are ones that can have their values read by Get <class> Properties or similar operations and can also have their values directly changed by Update <class> Properties operations. Properties that are classified as write-only can have their values directly changed by Update <class> Properties operations, but cannot have their values read by using Get <class> Properties or similar operations. Properties that are classified as read-only can have their values read by using Get <class> Properties or similar operations, but cannot have their values changed directly.
Although properties that are classified as read-only cannot have their values changed directly, their values may nonetheless be affected by other operations supported by a class of object. For example, a class of object might include an is-enabled property that is classified as read-only because the enabled state of the resource cannot be affected by a simple Update <class> Properties operation on that is-enabled property. However, this object might also define a Change State or Enable operation that can perform this enabling, and as a side effect will alter the value of the is-enabled property.
In addition to the read-only vs. writable classification, properties defined for a managed object also can differ in whether changes to them result in property change or status change notifications being emitted for the managed object or not. For properties that have property or status change support, these notifications are emitted asynchronously by the API any time the value of the property changes, whether that change was made through this API, the HMC UI, or implicitly by the system. Changes to the values of properties for which change notification support is not provided do not result in such notifications.
Most objects have properties
that are primarily configuration data. However, for some objects,
certain of those configuration-related properties may at times also
have a transient, runtime counterpart property in effect whose value
can be different than the preserved configuration or base value. That
transient, runtime counterpart property is known as an effective
property
and is identified as such in the object's data model by the (e) qualifier.
The name of an effective property is formed by prepending effective-
to
the name of its corresponding base property. Whether an object's effective
properties are applicable at any point in time is determined by the
state of the object or the state of the system or related objects
and is described in that object class' section of this document. The
object's effective-properties-apply property
indicates whether effective properties are currently applicable. If effective-properties-apply is false,
the value of an effective property is the same as its corresponding
base property and the effective property may not be altered by an
Update <class> Properties operation.
In some cases, an object in the management system may have properties whose values are unwieldy to provide or expensive to obtain and further may not be of general interest in typical API client use cases. To allow the handling of such properties to be optimized they are represented by a special kind of property termed a pseudo property. A pseudo property is conceptually one of the characteristics of a class of object and is thus documented in the data model for the object (with a (p) qualifier). However, the name and value of a pseudo property is not included in the response to a Get <class> Properties operation or in the inventory service data for that class of object. Instead, class-specific operations are provided in order to obtain the current value of the property when needed by an API client. As for normal properties, property change notifications may be generated for changes to a pseudo property if indicated in the data model.
There are times when it is convenient to provide a property of a related object as a property of itself. Such properties are referred to as ancillary properties (with an (a) qualifier). For example, an object that is hierarchically a child of another object may include its parent’s name as a property of its own. This property is not really part of the data model of the child's class of objects but may be provided as such for convenience. In these cases, Property Change support is not provided on the ancillary property, even if it is supported by the class of object to which it belongs.
In the tables of properties that appear within this document, the characteristics of properties are indicated by qualifier annotations in parenthesis following the property name. The qualifiers have the following meanings:
Qualifier notation | Description |
---|---|
(w) | The property is a writable property. Any property that lacks this qualifier and the (wo) qualifier is considered read-only and thus is not directly modifiable. |
(wo) | The property is a write-only property. Any property that lacks this qualifier and the (w) qualifier is considered read-only and thus is not directly modifiable. |
(ro) | Although this property is writable when present in other managed object classes, it is read only in this class. This qualifier is only used when a managed object class specializes the definition of a base managed object property and overrides the writable characteristic of the base definition. |
(p) | The property is a pseudo property. Its current value is omitted from the response to a Get <class> Properties operation or inventory service data for the object, but can be obtained by a class-specific operation. |
(pc) | Change to this property's value will result in Property Change notifications. |
(c) | The property is a container-type property for which deltas (changes) are reported in Property Change notifications rather than complete old and new values. |
(sc) | Change to this property will result in Status Change notifications. |
(mg) | This property represents a performance or utilization metric of the object that is included in a metric group available through the Metrics Service of this API. The value of this property may change very frequently and, therefore, property change notifications are not emitted for changes to this property. Client applications interested in obtaining metric information frequently should obtain this information through use of the Metrics Service of this API. |
(e) | The property is an effective property. |
(a) | The property is an ancillary property of the class of objects in which it is defined and is owned by a related class of objects. |