--- /dev/null
+module ietf-alarms {
+ yang-version 1.1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-alarms";
+ prefix al;
+
+ import ietf-yang-types {
+ prefix yang;
+ reference
+ "RFC 6991: Common YANG Data Types.";
+ }
+
+ organization
+ "IETF CCAMP Working Group";
+ contact
+ "WG Web: <https://trac.ietf.org/trac/ccamp>
+ WG List: <mailto:ccamp@ietf.org>
+
+ Editor: Stefan Vallin
+ <mailto:stefan@wallan.se>
+
+ Editor: Martin Bjorklund
+ <mailto:mbj@tail-f.com>";
+ description
+ "This module defines an interface for managing alarms. Main
+ inputs to the module design are the 3GPP Alarm Integration
+ Reference Point (IRP), ITU-T X.733, and ANSI/ISA-18.2 alarm
+ standards.
+ Main features of this module include:
+
+ * Alarm list:
+ A list of all alarms. Cleared alarms stay in
+ the list until explicitly purged.
+
+ * Operator actions on alarms:
+ Acknowledging and closing alarms.
+
+ * Administrative actions on alarms:
+ Purging alarms from the list according to specific
+ criteria.
+
+ * Alarm inventory:
+ A management application can read all
+ alarm types implemented by the system.
+
+ * Alarm shelving:
+ Shelving (blocking) alarms according
+ to specific criteria.
+
+ * Alarm profiles:
+ A management system can attach further
+ information to alarm types, for example,
+ overriding system-default severity
+ levels.
+
+ This module uses a stateful view on alarms. An alarm is a state
+ for a specific resource (note that an alarm is not a
+ notification). An alarm type is a possible alarm state for a
+ resource. For example, the tuple:
+
+ ('link-alarm', 'GigabitEthernet0/25')
+
+ is an alarm of type 'link-alarm' on the resource
+ 'GigabitEthernet0/25'.
+
+ Alarm types are identified using YANG identities and an optional
+ string-based qualifier. The string-based qualifier allows for
+ dynamic extension of the statically defined alarm types. Alarm
+ types identify a possible alarm state and not the individual
+ notifications. For example, the traditional 'link-down' and
+ 'link-up' notifications are two notifications referring to the
+ same alarm type 'link-alarm'.
+
+ With this design, there is no ambiguity about how alarm and
+ alarm clear correlation should be performed; notifications that
+ report the same resource and alarm type are considered updates
+ of the same alarm, e.g., clearing an active alarm or changing
+ the severity of an alarm. The instrumentation can update the
+ severity and alarm text on an existing alarm. The above alarm
+ example can therefore look like the following:
+
+ (('link-alarm', 'GigabitEthernet0/25'),
+ warning,
+ 'interface down while interface admin state is up')
+
+ There is a clear separation between updates on the alarm from
+ the underlying resource, like clear, and updates from an
+ operator, like acknowledging or closing an alarm:
+
+ (('link-alarm', 'GigabitEthernet0/25'),
+ warning,
+ 'interface down while interface admin state is up',
+ cleared,
+ closed)
+
+ Administrative actions like removing closed alarms older than a
+ given time is supported.
+
+ This YANG module does not define how the underlying
+ instrumentation detects and clears the specific alarms. That
+ belongs to the Standards Development Organization (SDO) or
+ enterprise that owns that specific technology.
+
+ The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
+ NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
+ 'MAY', and 'OPTIONAL' in this document are to be interpreted as
+ described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
+ they appear in all capitals, as shown here.
+
+ Copyright (c) 2019 IETF Trust and the persons identified as
+ authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject to
+ the license terms contained in, the Simplified BSD License set
+ forth in Section 4.c of the IETF Trust's Legal Provisions
+ Relating to IETF Documents
+ (https://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 8632; see
+ the RFC itself for full legal notices.";
+
+ revision 2019-09-11 {
+ description
+ "Initial revision.";
+ reference
+ "RFC 8632: A YANG Data Model for Alarm Management";
+ }
+
+ /*
+ * Features
+ */
+
+ feature operator-actions {
+ description
+ "This feature indicates that the system supports operator
+ states on alarms.";
+ }
+
+ feature alarm-shelving {
+ description
+ "This feature indicates that the system supports shelving
+ (blocking) alarms.
+
+ Alarm shelving may have an impact on server processing
+ resources in order to match alarms against shelf
+ criteria.";
+ }
+
+ feature alarm-history {
+ description
+ "This feature indicates that the server maintains a history
+ of state changes for each alarm. For example, if an alarm
+ toggles between cleared and active 10 times, these state
+ changes are present in a separate list in the alarm.
+
+ Keeping the alarm history may have an impact on server
+ memory resources.";
+ }
+
+ feature alarm-summary {
+ description
+ "This feature indicates that the server summarizes the number
+ of alarms per severity and operator state.";
+ }
+
+ feature alarm-profile {
+ description
+ "The system enables clients to configure further information
+ to each alarm type.";
+ }
+
+ feature severity-assignment {
+ description
+ "The system supports configurable alarm severity levels.";
+ reference
+ "ITU-T Recommendation M.3100:
+ Generic network information model
+ ITU-T Recommendation M.3160:
+ Generic, protocol-neutral management information model";
+ }
+
+ feature root-cause-analysis {
+ description
+ "The system supports identifying candidate root-cause
+ resources for an alarm, for example, a disk partition
+ root cause for a logger failure alarm.";
+ }
+
+ feature service-impact-analysis {
+ description
+ "The system supports identifying candidate-impacted
+ resources for an alarm, for example, an interface state change
+ resulting in a link alarm, which can refer to a link as being
+ impacted.";
+ }
+
+ feature alarm-correlation {
+ description
+ "The system supports correlating/grouping alarms
+ that belong together.";
+ }
+
+ /*
+ * Identities
+ */
+
+ identity alarm-type-id {
+ description
+ "Base identity for alarm types. A unique identification of
+ the alarm, not including the resource. Different resources
+ can share alarm types. If the resource reports the same
+ alarm type, it is considered to be the same alarm. The alarm
+ type is a simplification of the different X.733 and 3GPP Alarm
+ IRP correlation mechanisms, and it allows for
+ hierarchical extensions.
+
+ A string-based qualifier can be used in addition to the
+ identity in order to have different alarm types based on
+ information not known at design time, such as values in
+ textual SNMP Notification varbinds.
+
+ Standards and vendors can define sub-identities to clearly
+ identify specific alarm types.
+
+ This identity is abstract and MUST NOT be used for alarms.";
+ }
+
+ /*
+ * Common types
+ */
+
+ typedef resource {
+ type union {
+ type instance-identifier {
+ require-instance false;
+ }
+ type yang:object-identifier;
+ type string;
+ type yang:uuid;
+ }
+ description
+ "This is an identification of the alarming resource, such as an
+ interface. It should be as fine-grained as possible to both
+ guide the operator and guarantee uniqueness of the alarms.
+
+ If the alarming resource is modeled in YANG, this type will
+ be an instance-identifier.
+
+ If the resource is an SNMP object, the type will be an
+ 'object-identifier'.
+
+ If the resource is anything else, for example, a distinguished
+ name or a Common Information Model (CIM) path, this type will
+ be a string.
+
+ If the alarming object is identified by a Universally Unique
+ Identifier (UUID), use the uuid type. Be cautious when using
+ this type, since a UUID is hard to use for an operator.
+
+ If the server supports several models, the precedence should
+ be in the order as given in the union definition.";
+ }
+
+ typedef resource-match {
+ type union {
+ type yang:xpath1.0;
+ type yang:object-identifier;
+ type string;
+ }
+ description
+ "This type is used to match resources of type 'resource'.
+ Since the type 'resource' is a union of different types, the
+ 'resource-match' type is also a union of corresponding types.
+
+ If the type is given as an XPath 1.0 expression, a resource
+ of type 'instance-identifier' matches if the instance is part
+ of the node set that is the result of evaluating the XPath 1.0
+ expression. For example, the XPath 1.0 expression:
+
+ /ietf-interfaces:interfaces/ietf-interfaces:interface
+ [ietf-interfaces:type='ianaift:ethernetCsmacd']
+
+ would match the resource instance-identifier:
+
+ /if:interfaces/if:interface[if:name='eth1'],
+
+ assuming that the interface 'eth1' is of type
+ 'ianaift:ethernetCsmacd'.
+
+ If the type is given as an object identifier, a resource of
+ type 'object-identifier' matches if the match object
+ identifier is a prefix of the resource's object identifier.
+ For example, the value:
+
+ 1.3.6.1.2.1.2.2
+
+ would match the resource object identifier:
+
+ 1.3.6.1.2.1.2.2.1.1.5
+
+ If the type is given as an UUID or a string, it is interpreted
+ as an XML Schema regular expression, which matches a resource
+ of type 'yang:uuid' or 'string' if the given regular
+ expression matches the resource string.
+
+ If the type is given as an XPath expression, it is evaluated
+ in the following XPath context:
+
+ o The set of namespace declarations is the set of prefix
+ and namespace pairs for all YANG modules implemented by
+ the server, where the prefix is the YANG module name and
+ the namespace is as defined by the 'namespace' statement
+ in the YANG module.
+
+ If a leaf of this type is encoded in XML, all namespace
+ declarations in scope on the leaf element are added to
+ the set of namespace declarations. If a prefix found in
+ the XML is already present in the set of namespace
+ declarations, the namespace in the XML is used.
+
+ o The set of variable bindings is empty.
+
+ o The function library is the core function library, and
+ the functions are defined in Section 10 of RFC 7950.
+
+ o The context node is the root node in the data tree.";
+ reference
+ "XML Schema Part 2: Datatypes Second Edition,
+ World Wide Web Consortium Recommendation
+ REC-xmlschema-2-20041028";
+ }
+
+ typedef alarm-text {
+ type string;
+ description
+ "The string used to inform operators about the alarm. This
+ MUST contain enough information for an operator to be able to
+ understand the problem and how to resolve it. If this string
+ contains structure, this format should be clearly documented
+ for programs to be able to parse that information.";
+ }
+
+ typedef severity {
+ type enumeration {
+ enum indeterminate {
+ value 2;
+ description
+ "Indicates that the severity level could not be
+ determined. This level SHOULD be avoided.";
+ }
+ enum warning {
+ value 3;
+ description
+ "The 'warning' severity level indicates the detection of a
+ potential or impending service-affecting fault, before any
+ significant effects have been felt. Action should be
+ taken to further diagnose (if necessary) and correct the
+ problem in order to prevent it from becoming a more
+ serious service-affecting fault.";
+ }
+ enum minor {
+ value 4;
+ description
+ "The 'minor' severity level indicates the existence of a
+ non-service-affecting fault condition and that corrective
+ action should be taken in order to prevent a more serious
+ (for example, service-affecting) fault. Such a severity
+ can be reported, for example, when the detected alarm
+ condition is not currently degrading the capacity of the
+ resource.";
+ }
+ enum major {
+ value 5;
+ description
+ "The 'major' severity level indicates that a service-
+ affecting condition has developed and an urgent corrective
+ action is required. Such a severity can be reported, for
+ example, when there is a severe degradation in the
+ capability of the resource and its full capability must be
+ restored.";
+ }
+ enum critical {
+ value 6;
+ description
+ "The 'critical' severity level indicates that a service-
+ affecting condition has occurred and an immediate
+ corrective action is required. Such a severity can be
+ reported, for example, when a resource becomes totally out
+ of service and its capability must be restored.";
+ }
+ }
+ description
+ "The severity level of the alarm. Note well that the value
+ 'clear' is not included. Whether or not an alarm is cleared
+ is a separate boolean flag.";
+ reference
+ "ITU-T Recommendation X.733: Information Technology
+ - Open Systems Interconnection
+ - System Management: Alarm Reporting Function";
+ }
+
+ typedef severity-with-clear {
+ type union {
+ type enumeration {
+ enum cleared {
+ value 1;
+ description
+ "The alarm is cleared by the instrumentation.";
+ }
+ }
+ type severity;
+ }
+ description
+ "The severity level of the alarm including clear. This is used
+ only in notifications reporting state changes for an alarm.";
+ }
+
+ typedef writable-operator-state {
+ type enumeration {
+ enum none {
+ value 1;
+ description
+ "The alarm is not being taken care of.";
+ }
+ enum ack {
+ value 2;
+ description
+ "The alarm is being taken care of. Corrective action not
+ taken yet or has failed";
+ }
+ enum closed {
+ value 3;
+ description
+ "Corrective action taken successfully.";
+ }
+ }
+ description
+ "Operator states on an alarm. The 'closed' state indicates
+ that an operator considers the alarm being resolved. This is
+ separate from the alarm's 'is-cleared' leaf.";
+ }
+
+ typedef operator-state {
+ type union {
+ type writable-operator-state;
+ type enumeration {
+ enum shelved {
+ value 4;
+ description
+ "The alarm is shelved. Alarms in /alarms/shelved-alarms/
+ MUST be assigned this operator state by the server as
+ the last entry in the 'operator-state-change' list. The
+ text for that entry SHOULD include the shelf name.";
+ }
+ enum un-shelved {
+ value 5;
+ description
+ "The alarm is moved back to 'alarm-list' from a shelf.
+ Alarms that are moved from /alarms/shelved-alarms/ to
+ /alarms/alarm-list MUST be assigned this state by the
+ server as the last entry in the 'operator-state-change'
+ list. The text for that entry SHOULD include the shelf
+ name.";
+ }
+ }
+ }
+ description
+ "Operator states on an alarm. The 'closed' state indicates
+ that an operator considers the alarm being resolved. This is
+ separate from the alarm's 'is-cleared' leaf.";
+ }
+
+ /* Alarm type */
+
+ typedef alarm-type-id {
+ type identityref {
+ base alarm-type-id;
+ }
+ description
+ "Identifies an alarm type. The description of the alarm type
+ id MUST indicate whether or not the alarm type is abstract.
+ An abstract alarm type is used as a base for other alarm type
+ ids and will not be used as a value for an alarm or be present
+ in the alarm inventory.";
+ }
+
+ typedef alarm-type-qualifier {
+ type string;
+ description
+ "If an alarm type cannot be fully specified at design time by
+ 'alarm-type-id', this string qualifier is used in addition to
+ fully define a unique alarm type.
+
+ The definition of alarm qualifiers is considered to be part of
+ the instrumentation and is out of scope for this module. An
+ empty string is used when this is part of a key.";
+ }
+
+ /*
+ * Groupings
+ */
+
+ grouping common-alarm-parameters {
+ description
+ "Common parameters for an alarm.
+
+ This grouping is used both in the alarm list and in the
+ notification representing an alarm-state change.";
+ leaf resource {
+ type resource;
+ mandatory true;
+ description
+ "The alarming resource. See also 'alt-resource'. This could
+ be, for example, a reference to the alarming interface";
+ }
+ leaf alarm-type-id {
+ type alarm-type-id;
+ mandatory true;
+ description
+ "This leaf and the leaf 'alarm-type-qualifier' together
+ provide a unique identification of the alarm type.";
+ }
+ leaf alarm-type-qualifier {
+ type alarm-type-qualifier;
+ description
+ "This leaf is used when the 'alarm-type-id' leaf cannot
+ uniquely identify the alarm type. Normally, this is not the
+ case, and this leaf is the empty string.";
+ }
+ leaf-list alt-resource {
+ type resource;
+ description
+ "Used if the alarming resource is available over other
+ interfaces. This field can contain SNMP OIDs, CIM paths, or
+ 3GPP distinguished names, for example.";
+ }
+ list related-alarm {
+ if-feature "alarm-correlation";
+ key "resource alarm-type-id alarm-type-qualifier";
+ description
+ "References to related alarms. Note that the related alarm
+ might have been purged from the alarm list.";
+ leaf resource {
+ type leafref {
+ path "/alarms/alarm-list/alarm/resource";
+ require-instance false;
+ }
+ description
+ "The alarming resource for the related alarm.";
+ }
+ leaf alarm-type-id {
+ type leafref {
+ path "/alarms/alarm-list/alarm"
+ + "[resource=current()/../resource]"
+ + "/alarm-type-id";
+ require-instance false;
+ }
+ description
+ "The alarm type identifier for the related alarm.";
+ }
+ leaf alarm-type-qualifier {
+ type leafref {
+ path "/alarms/alarm-list/alarm"
+ + "[resource=current()/../resource]"
+ + "[alarm-type-id=current()/../alarm-type-id]"
+ + "/alarm-type-qualifier";
+ require-instance false;
+ }
+ description
+ "The alarm qualifier for the related alarm.";
+ }
+ }
+ leaf-list impacted-resource {
+ if-feature "service-impact-analysis";
+ type resource;
+ description
+ "Resources that might be affected by this alarm. If the
+ system creates an alarm on a resource and also has a mapping
+ to other resources that might be impacted, these resources
+ can be listed in this leaf-list. In this way, the system
+ can create one alarm instead of several. For example, if an
+ interface has an alarm, the 'impacted-resource' can
+ reference the aggregated port channels.";
+ }
+ leaf-list root-cause-resource {
+ if-feature "root-cause-analysis";
+ type resource;
+ description
+ "Resources that are candidates for causing the alarm. If the
+ system has a mechanism to understand the candidate root
+ causes of an alarm, this leaf-list can be used to list the
+ root-cause candidate resources. In this way, the system can
+ create one alarm instead of several. An example might be a
+ logging system (alarm resource) that fails; the alarm can
+ reference the file system in the 'root-cause-resource'
+ leaf-list. Note that the intended use is not to also send
+ an alarm with the 'root-cause-resource' as an alarming
+ resource. The 'root-cause-resource' leaf-list is a hint and
+ should not also generate an alarm for the same problem.";
+ }
+ }
+
+ grouping alarm-state-change-parameters {
+ description
+ "Parameters for an alarm-state change.
+
+ This grouping is used both in the alarm list's status-change
+ list and in the notification representing an alarm-state
+ change.";
+ leaf time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "The time the status of the alarm changed. The value
+ represents the time the real alarm-state change appeared in
+ the resource and not when it was added to the alarm
+ list. The /alarm-list/alarm/last-changed MUST be set to the
+ same value.";
+ }
+ leaf perceived-severity {
+ type severity-with-clear;
+ mandatory true;
+ description
+ "The severity of the alarm as defined by X.733. Note that
+ this may not be the original severity since the alarm may
+ have changed severity.";
+ reference
+ "ITU-T Recommendation X.733: Information Technology
+ - Open Systems Interconnection
+ - System Management: Alarm Reporting Function";
+ }
+ leaf alarm-text {
+ type alarm-text;
+ mandatory true;
+ description
+ "A user-friendly text describing the alarm-state change.";
+ reference
+ "ITU-T Recommendation X.733: Information Technology
+ - Open Systems Interconnection
+ - System Management: Alarm Reporting Function";
+ }
+ }
+
+ grouping operator-parameters {
+ description
+ "This grouping defines parameters that can be changed by an
+ operator.";
+ leaf time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "Timestamp for operator action on the alarm.";
+ }
+ leaf operator {
+ type string;
+ mandatory true;
+ description
+ "The name of the operator that has acted on this alarm.";
+ }
+ leaf state {
+ type operator-state;
+ mandatory true;
+ description
+ "The operator's view of the alarm state.";
+ }
+ leaf text {
+ type string;
+ description
+ "Additional optional textual information provided by the
+ operator.";
+ }
+ }
+
+ grouping resource-alarm-parameters {
+ description
+ "Alarm parameters that originate from the resource view.";
+ leaf is-cleared {
+ type boolean;
+ mandatory true;
+ description
+ "Indicates the current clearance state of the alarm. An
+ alarm might toggle from active alarm to cleared alarm and
+ back to active again.";
+ }
+ leaf last-raised {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "An alarm may change severity level and toggle between
+ active and cleared during its lifetime. This leaf indicates
+ the last time it was raised ('is-cleared' = 'false').";
+ }
+ leaf last-changed {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "A timestamp when the 'status-change' or
+ 'operator-state-change' list was last changed.";
+ }
+ leaf perceived-severity {
+ type severity;
+ mandatory true;
+ description
+ "The last severity of the alarm.
+
+ If an alarm was raised with severity 'warning' but later
+ changed to 'major', this leaf will show 'major'.";
+ }
+ leaf alarm-text {
+ type alarm-text;
+ mandatory true;
+ description
+ "The last reported alarm text. This text should contain
+ information for an operator to be able to understand the
+ problem and how to resolve it.";
+ }
+ list status-change {
+ if-feature "alarm-history";
+ key "time";
+ min-elements 1;
+ description
+ "A list of status-change events for this alarm.
+
+ The entry with latest timestamp in this list MUST
+ correspond to the leafs 'is-cleared', 'perceived-severity',
+ and 'alarm-text' for the alarm.
+
+ This list is ordered according to the timestamps of alarm
+ state changes. The first item corresponds to the latest
+ state change.
+
+ The following state changes create an entry in this
+ list:
+ - changed severity (warning, minor, major, critical)
+ - clearance status; this also updates the 'is-cleared'
+ leaf
+ - alarm-text update";
+ uses alarm-state-change-parameters;
+ }
+ }
+
+ grouping filter-input {
+ description
+ "Grouping to specify a filter construct on alarm information.";
+ leaf alarm-clearance-status {
+ type enumeration {
+ enum any {
+ description
+ "Ignore alarm-clearance status.";
+ }
+ enum cleared {
+ description
+ "Filter cleared alarms.";
+ }
+ enum not-cleared {
+ description
+ "Filter not-cleared alarms.";
+ }
+ }
+ mandatory true;
+ description
+ "The clearance status of the alarm.";
+ }
+ container older-than {
+ presence "Age specification";
+ description
+ "Matches the 'last-status-change' leaf in the alarm.";
+ choice age-spec {
+ description
+ "Filter using date and time age.";
+ case seconds {
+ leaf seconds {
+ type uint16;
+ description
+ "Age expressed in seconds.";
+ }
+ }
+ case minutes {
+ leaf minutes {
+ type uint16;
+ description
+ "Age expressed in minutes.";
+ }
+ }
+ case hours {
+ leaf hours {
+ type uint16;
+ description
+ "Age expressed in hours.";
+ }
+ }
+ case days {
+ leaf days {
+ type uint16;
+ description
+ "Age expressed in days.";
+ }
+ }
+ case weeks {
+ leaf weeks {
+ type uint16;
+ description
+ "Age expressed in weeks.";
+ }
+ }
+ }
+ }
+ container severity {
+ presence "Severity filter";
+ choice sev-spec {
+ description
+ "Filter based on severity level.";
+ leaf below {
+ type severity;
+ description
+ "Severity less than this leaf.";
+ }
+ leaf is {
+ type severity;
+ description
+ "Severity level equal to this leaf.";
+ }
+ leaf above {
+ type severity;
+ description
+ "Severity level higher than this leaf.";
+ }
+ }
+ description
+ "Filter based on severity.";
+ }
+ container operator-state-filter {
+ if-feature "operator-actions";
+ presence "Operator state filter";
+ leaf state {
+ type operator-state;
+ description
+ "Filter on operator state.";
+ }
+ leaf user {
+ type string;
+ description
+ "Filter based on which operator.";
+ }
+ description
+ "Filter based on operator state.";
+ }
+ }
+
+ /*
+ * The /alarms data tree
+ */
+
+ container alarms {
+ description
+ "The top container for this module.";
+ container control {
+ description
+ "Configuration to control the alarm behavior.";
+ leaf max-alarm-status-changes {
+ type union {
+ type uint16;
+ type enumeration {
+ enum infinite {
+ description
+ "The status-change entries are accumulated
+ infinitely.";
+ }
+ }
+ }
+ default "32";
+ description
+ "The 'status-change' entries are kept in a circular list
+ per alarm. When this number is exceeded, the oldest
+ status change entry is automatically removed. If the
+ value is 'infinite', the status-change entries are
+ accumulated infinitely.";
+ }
+ leaf notify-status-changes {
+ type enumeration {
+ enum all-state-changes {
+ description
+ "Send notifications for all status changes.";
+ }
+ enum raise-and-clear {
+ description
+ "Send notifications only for raise, clear, and
+ re-raise. Notifications for severity-level changes or
+ alarm-text changes are not sent.";
+ }
+ enum severity-level {
+ description
+ "Only send notifications for alarm-state changes
+ crossing the level specified in
+ 'notify-severity-level'. Always send clear
+ notifications.";
+ }
+ }
+ must '. != "severity-level" or ../notify-severity-level' {
+ description
+ "When notify-status-changes is 'severity-level', a value
+ must be given for 'notify-severity-level'.";
+ }
+ default "all-state-changes";
+ description
+ "This leaf controls the notifications sent for alarm status
+ updates. There are three options:
+
+ 1. Notifications are sent for all updates, severity-level
+ changes, and alarm-text changes.
+
+ 2. Notifications are only sent for alarm raise and clear.
+
+ 3. Notifications are sent for status changes equal to or
+ above the specified severity level. Clear
+ notifications shall always be sent. Notifications
+ shall also be sent for state changes that make an
+ alarm less severe than the specified level.
+
+ For example, in option 3, assume that the severity level
+ is set to major and that the alarm has the following state
+ changes:
+
+ [(Time, severity, clear)]:
+ [(T1, major, -), (T2, minor, -), (T3, warning, -),
+ (T4, minor, -), (T5, major, -), (T6, critical, -),
+ (T7, major. -), (T8, major, clear)]
+
+ In that case, notifications will be sent at times
+ T1, T2, T5, T6, T7, and T8.";
+ }
+ leaf notify-severity-level {
+ when '../notify-status-changes = "severity-level"';
+ type severity;
+ description
+ "Only send notifications for alarm-state changes crossing
+ the specified level. Always send clear notifications.";
+ }
+ container alarm-shelving {
+ if-feature "alarm-shelving";
+ description
+ "The 'alarm-shelving/shelf' list is used to shelve
+ (block/filter) alarms. The conditions in the shelf
+ criteria are logically ANDed. The first matching shelf is
+ used, and an alarm is shelved only for this first match.
+ Matching alarms MUST appear in the
+ /alarms/shelved-alarms/shelved-alarm list, and
+ non-matching /alarms MUST appear in the
+ /alarms/alarm-list/alarm list. The server does not send
+ any notifications for shelved alarms.
+
+ The server MUST maintain states (e.g., severity
+ changes) for the shelved alarms.
+
+ Alarms that match the criteria shall have an
+ operator state 'shelved'. When the shelf
+ configuration removes an alarm from the shelf, the server
+ shall add the operator state 'un-shelved'.";
+ list shelf {
+ key "name";
+ ordered-by user;
+ leaf name {
+ type string;
+ description
+ "An arbitrary name for the alarm shelf.";
+ }
+ description
+ "Each entry defines the criteria for shelving alarms.
+ Criteria are ANDed. If no criteria are specified,
+ all alarms will be shelved.";
+ leaf-list resource {
+ type resource-match;
+ description
+ "Shelve alarms for matching resources.";
+ }
+ list alarm-type {
+ key "alarm-type-id alarm-type-qualifier-match";
+ description
+ "Any alarm matching the combined criteria of
+ 'alarm-type-id' and 'alarm-type-qualifier-match'
+ MUST be matched.";
+ leaf alarm-type-id {
+ type alarm-type-id;
+ description
+ "Shelve all alarms that have an 'alarm-type-id' that
+ is equal to or derived from the given
+ 'alarm-type-id'.";
+ }
+ leaf alarm-type-qualifier-match {
+ type string;
+ description
+ "An XML Schema regular expression that is used to
+ match an alarm type qualifier. Shelve all alarms
+ that match this regular expression for the alarm
+ type qualifier.";
+ reference
+ "XML Schema Part 2: Datatypes Second Edition,
+ World Wide Web Consortium Recommendation
+ REC-xmlschema-2-20041028";
+ }
+ }
+ leaf description {
+ type string;
+ description
+ "An optional textual description of the shelf. This
+ description should include the reason for shelving
+ these alarms.";
+ }
+ }
+ }
+ }
+ container alarm-inventory {
+ config false;
+ description
+ "The 'alarm-inventory/alarm-type' list contains all possible
+ alarm types for the system.
+
+ If the system knows for which resources a specific alarm
+ type can appear, it is also identified in the inventory.
+ The list also tells if each alarm type has a corresponding
+ clear state. The inventory shall only contain concrete
+ alarm types.
+
+ The alarm inventory MUST be updated by the system when new
+ alarms can appear. This can be the case when installing new
+ software modules or inserting new card types. A
+ notification 'alarm-inventory-changed' is sent when the
+ inventory is changed.";
+ list alarm-type {
+ key "alarm-type-id alarm-type-qualifier";
+ description
+ "An entry in this list defines a possible alarm.";
+ leaf alarm-type-id {
+ type alarm-type-id;
+ description
+ "The statically defined alarm type identifier for this
+ possible alarm.";
+ }
+ leaf alarm-type-qualifier {
+ type alarm-type-qualifier;
+ description
+ "The optionally dynamically defined alarm type identifier
+ for this possible alarm.";
+ }
+ leaf-list resource {
+ type resource-match;
+ description
+ "Optionally, specifies for which resources the alarm type
+ is valid.";
+ }
+ leaf will-clear {
+ type boolean;
+ mandatory true;
+ description
+ "This leaf tells the operator if the alarm will be
+ cleared when the correct corrective action has been
+ taken. Implementations SHOULD strive for detecting the
+ cleared state for all alarm types.
+
+ If this leaf is 'true', the operator can monitor the
+ alarm until it becomes cleared after the corrective
+ action has been taken.
+
+ If this leaf is 'false', the operator needs to validate
+ that the alarm is no longer active using other
+ mechanisms. Alarms can lack a corresponding clear due
+ to missing instrumentation or no logical
+ corresponding clear state.";
+ }
+ leaf-list severity-level {
+ type severity;
+ description
+ "This leaf-list indicates the possible severity levels of
+ this alarm type. Note well that 'clear' is not part of
+ the severity type. In general, the severity level
+ should be defined by the instrumentation based on the
+ dynamic state, rather than being defined statically by
+ the alarm type, in order to provide a relevant severity
+ level based on dynamic state and context. However, most
+ alarm types have a defined set of possible severity
+ levels, and this should be provided here.";
+ }
+ leaf description {
+ type string;
+ mandatory true;
+ description
+ "A description of the possible alarm. It SHOULD include
+ information on possible underlying root causes and
+ corrective actions.";
+ }
+ }
+ }
+ container summary {
+ if-feature "alarm-summary";
+ config false;
+ description
+ "This container gives a summary of the number of alarms.";
+ list alarm-summary {
+ key "severity";
+ description
+ "A global summary of all alarms in the system. The summary
+ does not include shelved alarms.";
+ leaf severity {
+ type severity;
+ description
+ "Alarm summary for this severity level.";
+ }
+ leaf total {
+ type yang:gauge32;
+ description
+ "Total number of alarms of this severity level.";
+ }
+ leaf not-cleared {
+ type yang:gauge32;
+ description
+ "Total number of alarms of this severity level
+ that are not cleared.";
+ }
+ leaf cleared {
+ type yang:gauge32;
+ description
+ "For this severity level, the number of alarms that are
+ cleared.";
+ }
+ leaf cleared-not-closed {
+ if-feature "operator-actions";
+ type yang:gauge32;
+ description
+ "For this severity level, the number of alarms that are
+ cleared but not closed.";
+ }
+ leaf cleared-closed {
+ if-feature "operator-actions";
+ type yang:gauge32;
+ description
+ "For this severity level, the number of alarms that are
+ cleared and closed.";
+ }
+ leaf not-cleared-closed {
+ if-feature "operator-actions";
+ type yang:gauge32;
+ description
+ "For this severity level, the number of alarms that are
+ not cleared but closed.";
+ }
+ leaf not-cleared-not-closed {
+ if-feature "operator-actions";
+ type yang:gauge32;
+ description
+ "For this severity level, the number of alarms that are
+ not cleared and not closed.";
+ }
+ }
+ leaf shelves-active {
+ if-feature "alarm-shelving";
+ type empty;
+ description
+ "This is a hint to the operator that there are active
+ alarm shelves. This leaf MUST exist if the
+ /alarms/shelved-alarms/number-of-shelved-alarms is > 0.";
+ }
+ }
+ container alarm-list {
+ config false;
+ description
+ "The alarms in the system.";
+ leaf number-of-alarms {
+ type yang:gauge32;
+ description
+ "This object shows the total number of
+ alarms in the system, i.e., the total number
+ of entries in the alarm list.";
+ }
+ leaf last-changed {
+ type yang:date-and-time;
+ description
+ "A timestamp when the alarm list was last
+ changed. The value can be used by a manager to
+ initiate an alarm resynchronization procedure.";
+ }
+ list alarm {
+ key "resource alarm-type-id alarm-type-qualifier";
+ description
+ "The list of alarms. Each entry in the list holds one
+ alarm for a given alarm type and resource. An alarm can
+ be updated from the underlying resource or by the user.
+ The following leafs are maintained by the resource:
+ 'is-cleared', 'last-change', 'perceived-severity', and
+ 'alarm-text'. An operator can change 'operator-state' and
+ 'operator-text'.
+
+ Entries appear in the alarm list the first time an alarm
+ becomes active for a given alarm type and resource.
+ Entries do not get deleted when the alarm is cleared.
+ Clear status is represented as a boolean flag.
+
+ Alarm entries are removed, i.e., purged, from the list by
+ an explicit purge action. For example, purge all alarms
+ that are cleared and in closed operator state that are
+ older than 24 hours. Purged alarms are removed from the
+ alarm list. If the alarm resource state changes after a
+ purge, the alarm will reappear in the alarm list.
+
+ Systems may also remove alarms based on locally configured
+ policies; this is out of scope for this module.";
+ uses common-alarm-parameters;
+ leaf time-created {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "The timestamp when this alarm entry was created. This
+ represents the first time the alarm appeared; it can
+ also represent that the alarm reappeared after a purge.
+ Further state changes of the same alarm do not change
+ this leaf; these changes will update the 'last-changed'
+ leaf.";
+ }
+ uses resource-alarm-parameters;
+ list operator-state-change {
+ if-feature "operator-actions";
+ key "time";
+ description
+ "This list is used by operators to indicate the state of
+ human intervention on an alarm. For example, if an
+ operator has seen an alarm, the operator can add a new
+ item to this list indicating that the alarm is
+ acknowledged.";
+ uses operator-parameters;
+ }
+ action set-operator-state {
+ if-feature "operator-actions";
+ description
+ "This is a means for the operator to indicate the level
+ of human intervention on an alarm.";
+ input {
+ leaf state {
+ type writable-operator-state;
+ mandatory true;
+ description
+ "Set this operator state.";
+ }
+ leaf text {
+ type string;
+ description
+ "Additional optional textual information.";
+ }
+ }
+ }
+ notification operator-action {
+ if-feature "operator-actions";
+ description
+ "This notification is used to report that an operator
+ acted upon an alarm.";
+ uses operator-parameters;
+ }
+ }
+ action purge-alarms {
+ description
+ "This operation requests that the server delete entries
+ from the alarm list according to the supplied criteria.
+
+ Typically, this operation is used to delete alarms that
+ are in closed operator state and older than a specified
+ time.
+
+ The number of purged alarms is returned as an output
+ parameter.";
+ input {
+ uses filter-input;
+ }
+ output {
+ leaf purged-alarms {
+ type uint32;
+ description
+ "Number of purged alarms.";
+ }
+ }
+ }
+ action compress-alarms {
+ if-feature "alarm-history";
+ description
+ "This operation requests that the server compress
+ entries in the alarm list by removing all but the
+ latest 'status-change' entry for all matching alarms.
+ Conditions in the input are logically ANDed. If no
+ input condition is given, all alarms are compressed.";
+ input {
+ leaf resource {
+ type resource-match;
+ description
+ "Compress the alarms matching this resource.";
+ }
+ leaf alarm-type-id {
+ type leafref {
+ path "/alarms/alarm-list/alarm/alarm-type-id";
+ require-instance false;
+ }
+ description
+ "Compress alarms with this 'alarm-type-id'.";
+ }
+ leaf alarm-type-qualifier {
+ type leafref {
+ path "/alarms/alarm-list/alarm/alarm-type-qualifier";
+ require-instance false;
+ }
+ description
+ "Compress the alarms with this
+ 'alarm-type-qualifier'.";
+ }
+ }
+ output {
+ leaf compressed-alarms {
+ type uint32;
+ description
+ "Number of compressed alarm entries.";
+ }
+ }
+ }
+ }
+ container shelved-alarms {
+ if-feature "alarm-shelving";
+ config false;
+ description
+ "The shelved alarms. Alarms appear here if they match the
+ criteria in /alarms/control/alarm-shelving. This list does
+ not generate any notifications. The list represents alarms
+ that are considered not relevant by the operator. Alarms in
+ this list have an 'operator-state' of 'shelved'. This
+ cannot be changed.";
+ leaf number-of-shelved-alarms {
+ type yang:gauge32;
+ description
+ "This object shows the total number of current
+ alarms, i.e., the total number of entries
+ in the alarm list.";
+ }
+ leaf shelved-alarms-last-changed {
+ type yang:date-and-time;
+ description
+ "A timestamp when the shelved-alarm list was last changed.
+ The value can be used by a manager to initiate an alarm
+ resynchronization procedure.";
+ }
+ list shelved-alarm {
+ key "resource alarm-type-id alarm-type-qualifier";
+ description
+ "The list of shelved alarms. Shelved alarms can only be
+ updated from the underlying resource; no operator actions
+ are supported.";
+ uses common-alarm-parameters;
+ leaf shelf-name {
+ type leafref {
+ path "/alarms/control/alarm-shelving/shelf/name";
+ require-instance false;
+ }
+ description
+ "The name of the shelf.";
+ }
+ uses resource-alarm-parameters;
+ list operator-state-change {
+ if-feature "operator-actions";
+ key "time";
+ description
+ "This list is used by operators to indicate the state of
+ human intervention on an alarm. For shelved alarms, the
+ system has set the list item in the list to 'shelved'.";
+ uses operator-parameters;
+ }
+ }
+ action purge-shelved-alarms {
+ description
+ "This operation requests that the server delete entries from
+ the shelved-alarm list according to the supplied criteria.
+ In the shelved-alarm list, it makes sense to delete alarms
+ that are not relevant anymore.
+
+ The number of purged alarms is returned as an output
+ parameter.";
+ input {
+ uses filter-input;
+ }
+ output {
+ leaf purged-alarms {
+ type uint32;
+ description
+ "Number of purged alarms.";
+ }
+ }
+ }
+ action compress-shelved-alarms {
+ if-feature "alarm-history";
+ description
+ "This operation requests that the server compress entries
+ in the shelved-alarm list by removing all but the latest
+ 'status-change' entry for all matching shelved alarms.
+ Conditions in the input are logically ANDed. If no input
+ condition is given, all alarms are compressed.";
+ input {
+ leaf resource {
+ type leafref {
+ path "/alarms/shelved-alarms/shelved-alarm/resource";
+ require-instance false;
+ }
+ description
+ "Compress the alarms with this resource.";
+ }
+ leaf alarm-type-id {
+ type leafref {
+ path "/alarms/shelved-alarms/shelved-alarm"
+ + "/alarm-type-id";
+ require-instance false;
+ }
+ description
+ "Compress alarms with this 'alarm-type-id'.";
+ }
+ leaf alarm-type-qualifier {
+ type leafref {
+ path "/alarms/shelved-alarms/shelved-alarm"
+ + "/alarm-type-qualifier";
+ require-instance false;
+ }
+ description
+ "Compress the alarms with this
+ 'alarm-type-qualifier'.";
+ }
+ }
+ output {
+ leaf compressed-alarms {
+ type uint32;
+ description
+ "Number of compressed alarm entries.";
+ }
+ }
+ }
+ }
+ list alarm-profile {
+ if-feature "alarm-profile";
+ key "alarm-type-id alarm-type-qualifier-match resource";
+ ordered-by user;
+ description
+ "This list is used to assign further information or
+ configuration for each alarm type. This module supports a
+ mechanism where the client can override the system-default
+ alarm severity levels. The 'alarm-profile' is also a useful
+ augmentation point for specific additions to alarm types.";
+ leaf alarm-type-id {
+ type alarm-type-id;
+ description
+ "The alarm type identifier to match.";
+ }
+ leaf alarm-type-qualifier-match {
+ type string;
+ description
+ "An XML Schema regular expression that is used to match the
+ alarm type qualifier.";
+ reference
+ "XML Schema Part 2: Datatypes Second Edition,
+ World Wide Web Consortium Recommendation
+ REC-xmlschema-2-20041028";
+ }
+ leaf resource {
+ type resource-match;
+ description
+ "Specifies which resources to match.";
+ }
+ leaf description {
+ type string;
+ mandatory true;
+ description
+ "A description of the alarm profile.";
+ }
+ container alarm-severity-assignment-profile {
+ if-feature "severity-assignment";
+ description
+ "The client can override the system-default severity
+ level.";
+ reference
+ "ITU-T Recommendation M.3100:
+ Generic network information model
+ ITU-T Recommendation M.3160:
+ Generic, protocol-neutral management information model";
+ leaf-list severity-level {
+ type severity;
+ ordered-by user;
+ description
+ "Specifies the configured severity level(s) for the
+ matching alarm. If the alarm has several severity
+ levels, the leaf-list shall be given in rising severity
+ order. The original M3100/M3160 ASAP function only
+ allows for a one-to-one mapping between alarm type and
+ severity, but since YANG module supports stateful
+ alarms, the mapping must allow for several severity
+ levels.
+
+ Assume a high-utilization alarm type with two thresholds
+ with the system-default severity levels of threshold1 =
+ warning and threshold2 = minor. Setting this leaf-list
+ to (minor, major) will assign the severity levels as
+ threshold1 = minor and threshold2 = major";
+ }
+ }
+ }
+ }
+
+ /*
+ * Notifications
+ */
+
+ notification alarm-notification {
+ description
+ "This notification is used to report a state change for an
+ alarm. The same notification is used for reporting a newly
+ raised alarm, a cleared alarm, or changing the text and/or
+ severity of an existing alarm.";
+ uses common-alarm-parameters;
+ uses alarm-state-change-parameters;
+ }
+
+ notification alarm-inventory-changed {
+ description
+ "This notification is used to report that the list of possible
+ alarms has changed. This can happen when, for example, a new
+ software module is installed or a new physical card is
+ inserted.";
+ }
+}
Code Review / ccsdk / features.git / commitdiff