-- IDL module extracted from ITU-T X.780.2 (03/2007)
/**
Annex A (Normative) – Service-oriented modelling IDL
*/
/* This IDL code is intended to be stored in a file named "itut_x780_2.idl"
located in the search path used by IDL compilers on your system. Most comments
are formatted to be parsed by an IDL-to-HTML converter. */
#ifndef ITUT_X780_2_IDL
#define ITUT_X780_2_IDL
// ********************************
// * *
// * itut_x780_2.idl *
// * *
// ********************************
/*
This file defines an extensible, service-oriented NML-EML interface
in CORBA IDL, more generally an OS-OS interface according to Rec. M.3010,
where one OS takes a client/manager role (e.g., an NMS) and the other OS
takes a server/agent role (e.g., an EMS). The OS in a client role is called
managing system, and the OS in a server role is called managed system.
The IDL is organized into the following modules, interfaces,
operations, exceptions, attributes, data types, and constants.
module | interface | operation
-------------------+----------------------------+------------------------------
globaldefs | NamingAttributesIterator_I | next_n()
| | getLength()
| | destroy()
| ManagedEntityIterator_I | next_n()
| | getLength()
| | destroy()
common | Common_I | getAllManagedObjectNames()
| | getAllManagedObjects()
| | getManagedObject()
| | setNativeEMSName()
| | setUserLabel()
| | setOwner()
| | getCapabilities()
| | setAdditionalInfo()
| ManagedObjectIterator_I | next_n()
| | getLength()
| | destroy()
transmissionParameters | - | -
notifications | EventIterator _I | next_n()
| | getLength()
| | destroy()
module | exception, attribute | data type, constant
-------------------+----------------------------+------------------------------
globaldefs | ProcessingFailureException | Duration_T
| | ExceptionType_T
| | IterableManagedEntity_T
| | IterableManagedEntityList_T
| | NameAndStringList_T
| | NameAndStringValue_T
| | NLSList_T
| | NVSList_T
| | NamingAttributes_T
| | NamingAttributesList_T
| | TaggedParameters_T
| | TaggedParameterList_T
| | Time_T
common | - | Capability_T
| | CapabilityList_T
| | Common_T
| | ManagedObjectList_T
transmissionParameters | - | LayerRate_T
| | LayerRateList_T
| | LayeredParameters_T
| | LayeredParameterList_T
notifications | - | NT_OBJECT_CREATION
| | NT_OBJECT_DELETION
| | NT_ATTRIBUTE_VALUE_CHANGE
| | NT_STATE_CHANGE
| | NT_FILE_TRANSFER_STATUS
| | NT_BACKUP_STATUS
| | NT_HEARTBEAT
| | NT_ALARM
| | NT_TCA
| | Event_T
| | EventList_T
| | EventType_T
| | EventName_T
| | NotificationId_T
| | ObjectName_T
| | ObjectType_T
| | ObjectTypeQualifier_T
| | EmsTime_T
| | NeTime_T
| | EdgePointRelated_T
| | OCN_T
| | ODN_T
| | NameAndAnyValue_T
| | NVList_T
| | AVC_T
| | SCN_T
| | FileTransferStatus_T
| | FTS_T
| | Current_OperationStatus_T
| | BackupStatus_T
| | BSE_T
| | HBE_T
| | NativeEMSName_T
| | PerceivedSeverity_T
| | PerceivedSeverityList_T
| | ServiceAffecting_T
| | AffectedTPList_T
| | ProbableCause_T
| | ProbableCauseList_T
| | ProbableCauseQualifier_T
| | NativeProbableCause_T
| | AssignedSeverity_T
| | AlarmSeverityAssignment_T
| | AlarmSeverityAssignmentList_T
| | AdditionalText_T
| | AdditionalInfo_T
| | RcaiIndicator_T
| | IsClearable_T
| | AcknowledgeIndication_T
| | X733_EventType_T
| | X733_EventTime_T
| | SpecificProblem_T
| | SpecificProblemList_T
| | X733_BackupStatus_T
| | X733_BackupObject_T
| | X733_TrendIndication_T
| | NotifIDList_T
| | CorrelatedNotifications_T
| | CorrelatedNotificationList_T
| | X733_MonitoredAttributes_T
| | ProposedRepairAction_T
| | ProposedRepairActionList_T
| | X733_StateChange_T
| | X733_AdditionalInfo_T
| | AlarmId_T
| | ALM_T
| | PMParameterName_T
| | PMLocation_T
| | Granularity_T
| | PMThresholdType_T
| | TCAId_T
| | Value_T
| | Unit_T
| | TCA_T
| | AlarmTypeQualifier_T
| | AlarmOrTCAIdentifier_T
| | AlarmAndTCAIDList_T
*/
//Include list
#include "OMGidl/CosNotification.idl"
#pragma prefix "itu.int"
/**
A.1 Module globaldefs
*/
/**
* <p>This module defines common types and other IDL constructs
* used by all CORBA modules of the NML-EML interface.
* It is intended to be used as a common repository for definitions
* that need to be exported across modules.</p>
**/
module globaldefs
{
/**
* <p>The NameAndStringValue_T structure is provided here as a replacement of
* the NVList construct defined by the OMG. In consideration for performance
* and the cost associated with the marshalling of the any type, it is decided
* to use the type string for the value field instead of the any type.
* When used for name components the structure is equivalent to the
* CosNaming::NameComponent structure of the OMG Naming Service.</p>
**/
struct NameAndStringValue_T
{
string name;
string value;
};
/**
* <p>A list of (name=string, value=string) tuples, i.e.
* name/value pairs with string values (NVS pairs).</p>
*
* <p>For example, the additional info parameters of any service-oriented
* managed object (see module common) and the transmission parameters of a
* Termination Point (see module transmissionParameters) use this structure.
* When NVS pairs are used to specify parameters for usage in attributes of
* managed objects, a standardised naming scheme is adopted between the NMS
* and the EMS to identify the name and the value fields of NVS pairs.</p>
**/
typedef sequence<NameAndStringValue_T> NVSList_T;
/**
* <p>The NamingAttributes_T structure is used to define identifiers
* (names) for managed entities that are not instantiated as first class
* CORBA objects and thus do not have a CORBA object identifier (IOR).
* It represents "the hierarchical name structure" of a second class
* "non-CORBA" object (managed object); it is an attribute of the
* managed object that contains its full distinguished name (FDN). The
* structure of the name is hierarchical and reflects the containment
* relationship between managed objects in a simple way. It consists of
* an ordered list (sequence) of components where the preceding component
* is a containing entity for the following component (e.g., a network
* element contains a termination point).</p>
*
* <p>Refer to clause 10.3.2 "Structure of naming attribute of managed
* objects" of Rec. X.780.2 for further details.</p>
**/
typedef NVSList_T NamingAttributes_T;
/**
* <p>A list of NamingAttributes_T. It is a list of lists.</p>
**/
typedef sequence<NamingAttributes_T> NamingAttributesList_T;
/**
* <p>The NameAndStringList_T structure is provided here as a
* standard means to model multi-valued parameters with string values,
* i.e. parameters whose values are lists of strings (NVL pairs).</p>
**/
struct NameAndStringList_T
{
string name;
sequence<string> value;
};
/**
* <p>A list of (name=string, value=sequence<string>) tuples,
* i.e. name/value pairs with list of string values (NVL pairs).</p>
**/
typedef sequence<NameAndStringList_T> NLSList_T;
/**
* <p> The TaggedParameters_T structure relates a parameter list
* (i.e., list of NVS pairs) with a parameter tag.</p>
**/
struct TaggedParameters_T
{
unsigned long parameterTag;
NVSList_T taggedParams;
};
/**
* <p>A list of tagged parameters.</p>
**/
typedef sequence<TaggedParameters_T> TaggedParameterList_T;
/**
* <p>Time_T is a string holding a generalized time string as defined in
* clause 42 of ITU-T Rec. X.680 "Information technology - Abstract Syntax
* Notation One (ASN.1): Specification of basic notation". This string
* represents an absolute time value (calender date and time of day).</p>
*
* <p>The format is "yyyyMMddhhmmss.s[Z|{+|-}HHMm]" where:<br>
* <pre> yyyy "0000".."9999" year
* MM "01".."12" month
* dd "01".."31" day
* hh "00".."23" hour
* mm "00".."59" minute
* ss "00".."59" second
* .s ".0"..".9" tenth of second (set to ".0" if EMS
or NE cannot support this granularity)
* Z "Z" indicates UTC (rather than local time)
* {+|-} "+" or "-" delta from UTC
* HH "00".."23" time zone difference in hours
* Mm "00".."59" time zone difference in minutes</pre></p>
*
* <p>For example,<br> "19851106210627.3Z" would be 6 minutes, 27.3 seconds
* after 9 p.m. on November 6th, 1985 and indicating UTC time,<br>
* "19851106210627.3" would be local time,<br>
* "19851106210627.3+0500" would be local time specifying a +5 hour time
* zone difference from UTC,<br> "19851106210627.3-0530" would be local
* time specifying a -5.5 hour time zone difference from UTC.</p>
**/
typedef string Time_T;
/**
* <p>Duration_T represents a relative time value (duration) with unit
* 100 nanoseconds. For example, 18 * 10**9 represents 30 minutes.</p>
**/
typedef unsigned long long Duration_T;
/**
* <p><b>Exception Type Definitions</b></p>
*
* <p>As per CORBA policies agreement, only one exception object
* is defined to capture all of the possible exception types
* defined in the <b>ProcessingFailureException</b> exception.</p>
*
* <p><ul>
* <li> EXCPT_NOT_IMPLEMENTED
* <br>If some IDL operations are optional or not implemented,
* then this value may be used for this purpose. If the operation
* itself is not supported, then errorReason shall be an empty string.
* If this exception is raised because of the values of specific
* parameters (i.e., NV pairs), then the names of these parameters
* shall be supplied in errorReason (separated by commas), unless
* otherwise specified in the operation description.</li>
*
* <li> EXCPT_INTERNAL_ERROR
* <br>To indicate an EMS internal error. Applies to all operations.
* The errorReason can be used to provide further clarification.</li>
*
* <li> EXCPT_INVALID_INPUT
* <br>If the format of a parameter is incorrect (e.g., if a name
* which is a 3-level NamingAttributes_T is passed as a single level
* name), then this type will be used. Also if a parameter is out of
* range, this type will be used. The reason field will be filled
* with the parameter that was incorrect.</li>
*
* <li> EXCPT_OBJECT_IN_USE
* <br>To indicate that an object is already in use.</li>
*
* <li> EXCPT_ENTITY_NOT_FOUND
* <br>In general, if the NMS supplies an object name as a parameter
* to an operation and the EMS cannot find the object with the given
* name, then an exception of this type is returned. The errorReason
* field in the exception will be filled with the name that was passed
* in as a parameter.</li>
*
* <li> EXCPT_NOT_IN_VALID_STATE
* <br>Used if the client tries to delete an object that is
* in a state that prevents its deletion.</li>
*
* <li> EXCPT_UNABLE_TO_COMPLY
* <br>This value is used as a generic value when a server (EMS)
* cannot respond to the request and no other exception provides
* the appropriate clarification. The errorReason string is used
* to provide further information.</li>
*
* <li> EXCPT_NE_COMM_LOSS
* <br>This value is used as a generic value when a server (EMS) cannot
* communicate with the NE (Network Element) to which the operation
* should apply and that prevents the successful completion of
* the operation. All operations that involve communication with
* the NE may throw this particular exception type. Note that NE
* here applies to any device to which the server (EMS) will have
* to communicate to fulfill the operation.</li>
*
* <li> EXCPT_CAPACITY_EXCEEDED
* <br>Raised when an operation will result in resources being created
* or activated beyond the capacity supported by the NE/EMS.</li>
*
* <li> EXCPT_ACCESS_DENIED
* <br>Raised when an operation results in a security violation.</li>
*
* <li> EXCPT_TOO_MANY_OPEN_ITERATORS
* <br>Raised when the EMS exceeds its internal limit of the number
* of iterators it can support.</li>
*
* <li> EXCPT_USERLABEL_IN_USE
* <br>Raised when the userLabel uniqueness constraint can not be met.</li>
* </ul></p>
*
* <p>This standard framework exception list may be extended with more
* focussed exceptions that relate to the problem space to which the
* respective interface using the framework is applied. For example,
* an exception EXCPT_UNSUPPORTED_ROUTING_CONSTRAINTS may be specified
* where the framework has been used to develop an interface that
* relates to the problem of routing across a network. Standard OMG
* exceptions may also occur, e.g. NO_IMPLEMENT if an operation
* implementation is unavailable, but they should be documented
* with IDL comments similar to the standard ITU-T exceptions.</p>
*
* <p>Refer to clause 10.5.2.4 of Rec. X.780.2 for the general
* procedure, and to notifications::ObjectType_T as an example,
* of how to extend enum types. ExceptionType_T becomes extensible
* when EXCPT_INTERNAL_ERROR is considered to be the escape value
* and errorReason is used to convey new exception values
* according to the convention
* <code>"EXCPT_<new exception type>;<errorReason>"</code>.</p>
**/
enum ExceptionType_T
{
EXCPT_NOT_IMPLEMENTED,
EXCPT_INTERNAL_ERROR,
EXCPT_INVALID_INPUT,
EXCPT_OBJECT_IN_USE,
EXCPT_ENTITY_NOT_FOUND,
EXCPT_NOT_IN_VALID_STATE,
EXCPT_UNABLE_TO_COMPLY,
EXCPT_NE_COMM_LOSS,
EXCPT_CAPACITY_EXCEEDED,
EXCPT_ACCESS_DENIED,
EXCPT_TOO_MANY_OPEN_ITERATORS,
EXCPT_USERLABEL_IN_USE
};
/**
* <p>A coarse grain approach is adopted for capturing exceptions
* as well. This has the advantage of making the catching of exceptions
* fairly generic. Since CORBA does not allow as in the Java language
* to subclass exceptions, it is recommended to reduce the number
* of exceptions a client may catch as far as reasonably possible.
* On the down side, a client may need to write explicit code when
* an exception is thrown by the server (i.e., a client may need to
* have a switch statement on the exceptionType attribute).</p>
*
* ExceptionType_T <b>exceptionType</b>:
* See description of ExceptionType_T.<br>
* string <b>errorReason</b>: A string indicating further details about
* the exception. It is a free format string filled by the EMS.<br>
**/
exception ProcessingFailureException
{
ExceptionType_T exceptionType;
string errorReason;
};
/**
* <p>In order to allow the NMS to deal with retrieval of a large
* number of names, iterators are used for bulk retrieval of
* managed object names.</p>
*
* <p>Refer to clause 9.4 "Iterator interfaces" of Rec. X.780.2
* for information on how iterators are used in this interface.</p>
**/
interface NamingAttributesIterator_I
{
boolean next_n(
in unsigned long how_many,
out NamingAttributesList_T nameList)
raises(globaldefs::ProcessingFailureException);
unsigned long getLength()
raises(globaldefs::ProcessingFailureException);
void destroy()
raises(globaldefs::ProcessingFailureException);
}; // end of interface
/**
* <p>The IterableManagedEntity_T struct represents a generic managed
* entity type which is iterable (e.g., a managed object type).</p>
**/
struct IterableManagedEntity_T
{
// add any managed entity type-specific attributes here
globaldefs::NVSList_T additionalInfo;
};
/**
* <p>The IterableManagedEntityList_T structure represents a generic
* iterator batch consisting of generic iterable entities.</p>
**/
typedef sequence<IterableManagedEntity_T> IterableManagedEntityList_T;
/**
* <p>In order to allow the NMS to deal with retrieval of a large
* number of entities, iterators are used for bulk retrieval of
* managed entities.</p>
*
* <p>Refer to clause 9.4 "Iterator interfaces" of Rec. X.780.2
* for information on how iterators are used in this interface.</p>
*
* <p>The ManagedEntityIterator_I is a generic iterator.</p>
**/
interface ManagedEntityIterator_I
{
boolean next_n(
in unsigned long how_many,
out IterableManagedEntityList_T managedEntityList)
raises(globaldefs::ProcessingFailureException);
unsigned long getLength()
raises(globaldefs::ProcessingFailureException);
void destroy()
raises(globaldefs::ProcessingFailureException);
}; // end of interface
}; // end of module
/**
A.2 Module common
*/
/**
* <p>This module contains the definitions of the Common_T structure
* and the Common_I interface of the NML-EML interface.</p>
**/
module common
{
/**
* <p>A Capability_T value is used to identify a functionality supported by
* the EMS across the NML-EML interface. It is a name/value pair, in which
* the name represents the feature/capability name and the value represents
* the support or non-support of the specified feature/capability.</p>
*
* <p>The EMS capabilities include individual IDL operation support.
* The feature/capability name part is used to identify an IDL
* operation using the following convention (scoped operation name):
* "<i>module_name</i>::<i>interface_name</i>::<i>operation_name</i>".</p>
*
* <p>Applications of this framework may define a number of other
* specifiable capabilities in addition to the operation-oriented
* capabilities, e.g. regarding connectivity management
* or fault management.</p>
*
* <p>The currently defined values are as follows:<br>
* <ul>
* <li><b>"Supported"</b>: The specified feature/capability is
* fully or partially supported across the NML-EML interface,
* where an operation is partially supported if not all values
* of all parameters are supported.</li>
* <li><b>"Unsupported"</b>: The specified feature/capability is
* not supported at all across the NML-EML interface.</li>
* </ul></p>
*
* <p> Other capabilities may be added with the approval of an amendment
* to Rec. X.780.2, or through bilateral agreements. </p>
**/
typedef globaldefs::NameAndStringValue_T Capability_T;
/**
* <p> Set of Capability_T. Used to represent the full set of
* capabilities of a service-oriented façade. Any capability
* that is not listed is considered unsupported. </p>
*/
typedef sequence<Capability_T> CapabilityList_T;
/**
* <p>The struct Common_T defines the mandatory common
* attributes of each managed object class (MOC). This is
* often a "virtual" struct, meant to be renamed and extended
* whenever a specific MOC should be defined. It could also
* be used for the modelling of managed objects all of whose
* attributes are additional info parameters. Such a managed
* object without MOC-specific attributes (i.e., of
* IDL type Common_T) is called generic.</p>
*
* <p>The mandatory common attributes of managed objects are:<br>
* - globaldefs::NamingAttributes_T <b>name</b>:<br>
* The full distinguished name (FDN) of the managed object.<br>
* - string <b>userLabel</b>:<br>
* A friendly name that the operator wants to place for the
* managed object and get it used subsequently by the NMS.<br>
* - string <b>nativeEMSName</b>:<br>
* A representation how the managed object is referred to
* on EMS displays; its aim is to provide a "nomenclature
* bridge" to aid relating information presented on NMS
* displays to EMS displays (via GUI cut through).<br>
* - string <b>owner</b>:<br>
* The owner of the managed object as provisioned by the NMS,
* e.g. in the sense of a "used by" relationship.<br>
* - globaldefs::NVSList_T <b>additionalInfo</b>:<br>
* Additional information which is not explicitly modelled
* at the NML-EML interface but needs be communicated
* from the EMS to the NMS or vice versa. Such information
* may be standardised or vendor-specific.<br>
* </p>
**/
struct Common_T
{
globaldefs::NamingAttributes_T name;
string userLabel;
string nativeEMSName;
string owner;
// add any MOC-specific attributes here
globaldefs::NVSList_T additionalInfo;
};
/**
* <p> List of Common_T. Used to represent a batch of generic managed
* objects (i.e., which have only common attributes).</p>
*/
typedef sequence<Common_T> ManagedObjectList_T;
/**
* <p>In order to allow the NMS to deal with retrieval of a large number
* of objects, iterators are used for bulk retrieval of managed objects.</p>
*
* <p>Refer to clause 9.4 "Iterator interfaces" of Rec. X.780.2
* for information on how iterators are used in this interface.</p>
**/
interface ManagedObjectIterator_I
{
boolean next_n(
in unsigned long how_many,
out ManagedObjectList_T moList)
raises(globaldefs::ProcessingFailureException);
unsigned long getLength()
raises(globaldefs::ProcessingFailureException);
void destroy()
raises(globaldefs::ProcessingFailureException);
};
/**
* <p>The interface Common_I is a set of services and utilities
* that is inherited by every service-oriented façade interface.<p>
*
* <p>It allows to retrieve the capabilities of the respective
* concrete façade and to set the (settable) common attributes
* of any managed object that is being managed by the façade.</p>
**/
interface Common_I
{
/**
* <p>This allows an NMS to request the names of all of the generic
* Managed Objects that are under the control of this Common_I.</p>
*
* <p>In order to allow the NMS to deal with a large number of objects,
* this operation uses an iterator (see 9.4/X.780.2).</p>
*
* @parm unsigned long <b>how_many</b>: Maximum number of MO names
* to return in the first batch.
*
* @parm globaldefs::NamingAttributesList_T <b>nameList</b>:
* First batch of MO names.
*
* @parm globaldefs::NamingAttributesListIterator_I <b>nameIt</b>:
* Iterator to retrieve the remaining MO names.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_TOO_MANY_OPEN_ITERATORS - Raised when the maximum number of
* iterators that the EMS can support has been reached<br>
* </dir>
**/
void getAllManagedObjectNames(
in unsigned long how_many,
out globaldefs::NamingAttributesList_T nameList,
out globaldefs::NamingAttributesIterator_I nameIt)
raises(globaldefs::ProcessingFailureException);
/**
* <p>This operation has exactly the same behaviour as
* getAllManagedObjectNames, but instead of returning
* the names of the objects, this operation returns
* their entire object structures.</p>
*
* <p>This allows an NMS to request details of all of the generic
* Managed Objects that are under the control of this Common_I.</p>
*
* <p>In order to allow the NMS to deal with a large number of objects,
* this operation uses an iterator (see 9.4/X.780.2).</p>
*
* @parm unsigned long <b>how_many</b>: Maximum number of MOs
* to report in the first batch.
*
* @parm ManagedObjectList_T <b>moList</b>: First batch of MOs.
*
* @parm ManagedObjectIterator_I <b>moIt</b>:
* Iterator to retrieve the remaining MOs.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_TOO_MANY_OPEN_ITERATORS - Raised when the maximum number of
* iterators that the EMS can support has been reached<br>
* </dir>
**/
void getAllManagedObjects(
in unsigned long how_many,
out ManagedObjectList_T moList,
out ManagedObjectIterator_I moIt)
raises(globaldefs::ProcessingFailureException);
/**
* <p>This service returns the Managed Object for the given
* generic managed object name.</p>
*
* @parm globaldefs::NamingAttributes <b>objectName</b>:
* Name of the MO to retrieve.
*
* @parm Common_T <b>mo</b>: The retrieved MO.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_INVALID_INPUT - Raised when objectName does not reference a
* generic managed object<br>
* EXCPT_ENTITY_NOT_FOUND - Raised when objectName references an MO
* object that does not exist<br>
* EXCPT_NE_COMM_LOSS - Raised when communications to the managed
* element containing or hosting objectName is lost<br>
* </dir>
**/
void getManagedObject(
in globaldefs::NamingAttributes_T objectName,
out Common_T mo)
raises(globaldefs::ProcessingFailureException);
/**
* <p>The nativeEMSName is owned by the EMS. It represents how an EMS user
* addresses an object on the EMS GUI. The EMS may or may not support
* changing this value through this service.</p>
*
* <p>When an object is created by the EMS, the EMS selects the nativeEMSName
* for the object.</p>
*
* <p>When an object is created by an NMS, the NMS specifies the userLabel
* for the object. If the EMS supports setting of native EMS names, the
* nativeEMSName should be set to the same value as the userLabel. If the
* EMS does not support setting of native EMS names, or if the nativeEMSName
* has constraints that the userLabel does not satisfy, the EMS selects
* the nativeEMSName for the object.</p>
*
* <p>After an object has been created, the nativeEMSName may be changed by
* the NMS, if the EMS supports this functionality, using this operation.</p>
*
* @parm globaldefs::NamingAttributes_T <b>objectName</b>: Name of the object
* for which to change the native EMS name.<
*
* @parm string <b>nativeEMSName</b>: New native EMS name
* to assign to the object.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_NOT_IMPLEMENTED - Raised if the EMS does not support this service<br>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_INVALID_INPUT - Raised when objectName is incorrectly formed<br>
* EXCPT_ENTITY_NOT_FOUND - Raised when objectName references an object
* which does not exist<br>
* EXCPT_UNABLE_TO_COMPLY - Raised when the nativeEMSName can not be set
* for the specified object<br>
* EXCPT_NE_COMM_LOSS - Raised when communications to the managed element
* containing or hosting objectName is lost
* </dir>
**/
void setNativeEMSName(
in globaldefs::NamingAttributes_T objectName,
in string nativeEMSName)
raises(globaldefs::ProcessingFailureException);
/**
* <p>The userLabel is owned by the NMSes. It is a string assigned by
* an NMS to an object. A difference between the userLabel and the
* NamingAttributes_T name is that the userLabel is an attribute of
* the objects that may be cahanged by an NMS through this service.</p>
*
* <p>When an object is created by an NMS, the NMS specifies the userLabel
* for the object.</p>
*
* <p>When an object is created by the EMS, the EMS sets the userLabel
* to the nativeEMSName.</p>
*
* <p>Once an object is created, the userLabel may only be changed by
* an NMS through this operation.</p>
*
* @parm globaldefs::NamingAttributes_T <b>objectName</b>: Name of the object
* for which to change the user label.
*
* @parm string <b>userLabel</b>: New user label to assign to the object.
*
* @parm boolean <b>enforceUniqueness</b>: Specifies whether or not
* userLabel should be checked for uniqueness amongst objects of
* the same class within the EMS. If TRUE, then the operation will fail
* if userLabel is already in use.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_NOT_IMPLEMENTED - Raised if the EMS does not support this service<br>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_INVALID_INPUT - Raised when objectName is incorrectly formed<br>
* EXCPT_ENTITY_NOT_FOUND - Raised when objectName references an object
* which does not exist<br>
* EXCPT_UNABLE_TO_COMPLY - Raised when the userLabel can not be set
* for the specified object<br>
* EXCPT_NE_COMM_LOSS - Raised when communications to the managed element
* containing or hosting objectName is lost<br>
* EXCPT_USERLABEL_IN_USE - Raised when the userLabel uniqueness constraint
* is not met<br>
* </dir>
**/
void setUserLabel(
in globaldefs::NamingAttributes_T objectName,
in string userLabel,
in boolean enforceUniqueness)
raises(globaldefs::ProcessingFailureException);
/**
* <p>This service sets the owner attribute of the specified object.</p>
*
* @parm globaldefs::NamingAttributes_T <b>objectName</b>: Name of the object
* for which to change the owner.
*
* @parm string <b>owner</b>: New owner to assign to the object.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_NOT_IMPLEMENTED - Raised if the EMS does not support this service<br>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_INVALID_INPUT - Raised when objectName is incorrectly formed<br>
* EXCPT_ENTITY_NOT_FOUND - Raised when objectName references an object
* that does not exist<br>
* EXCPT_UNABLE_TO_COMPLY - Raised when the owner can not be set
* for the specified object<br>
* EXCPT_NE_COMM_LOSS - Raised when communications to the managed element
* containing or hosting objectName is lost<br>
* </dir>
**/
void setOwner(
in globaldefs::NamingAttributes_T objectName,
in string owner)
raises(globaldefs::ProcessingFailureException);
/**
* <p>This service retrieves the capabilities of the manager.
* All non-specified capabilities are assumed to be unsupported.</p>
*
* @parm CapabilityList_T <b>capabilities</b>: The retrieved capabilities.
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* </dir>
**/
void getCapabilities(
out CapabilityList_T capabilities)
raises(globaldefs::ProcessingFailureException);
/**
* <p>This service sets the additional info attribute of the object identified
* by objectName. This operation should be used to set both vendor-specific
* attributes as well as the attributes that are formally defined in
* standardised interface specifications that extend this framework.</p>
*
* <p>As an input only the list of parameters to be changed, removed,
* or added shall be provided. If an entry is to be removed, "-" shall
* be specified as a value. If a parameter is specified that is currently
* not part of the additionalInfo attribute of the specified object
* that parameter is added by the EMS with the specified value.
* The EMS may reject removal and addition requests, however.</p>
*
* <p>The operation is best effort except where specified otherwise
* for a particular parameter where this parameter is defined (i.e.,
* in a standardised or vendor-specific NML-EML interface specification
* that extends this framework). The output specifies the values which
* were actually set.</p>
*
* @parm globaldefs::NamingAttributes_T <b>objectName</b>: The managed object
* whose additional info parameters are intended to get modified.
*
* @parm globaldefs::NVSList_T <b>additionalInfo</b>: List of parameters
* to be changed, added, or removed (input), updated to provide the
* actually changed or added parameters (output).
*
* @raises globaldefs::ProcessingFailureException<dir>
* EXCPT_NOT_IMPLEMENTED - Raised if the EMS does not support this service<br>
* EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal
* failure<br>
* EXCPT_INVALID_INPUT - Raised when objectName is incorrectly formed,
* raised when an input parameter is syntactical incorrect, and raised
* when a parameter is identified as settable only by using a "specific
* operation" defined in a standardised NML-EML interface specification
* that extends this framework<br>
* EXCPT_ENTITY_NOT_FOUND - Raised when objectName references an object
* that does not exist<br>
* EXCPT_NE_COMM_LOSS - Raised when communications to the managed element
* containing or hosting objectName is lost<br>
* EXCPT_UNABLE_TO_COMPLY - Raised when the EMS is unable to execute the
* request because at least one of the parameters although valid can not
* be set and that parameter is identified as "not best effort" in a
* standardised interface specification that extends this framework<br>
* </dir>
**/
void setAdditionalInfo(
in globaldefs::NamingAttributes_T objectName,
inout globaldefs::NVSList_T additionalInfo)
raises(globaldefs::ProcessingFailureException);
}; // end of interface
}; // end of module
/**
A.3 Module transmissionParameters
*/
/**
* <p>This module contains the generic definitions of Layer rates, which
* identify telecom transmission technologies, and of single-layer and
* multi-layer transmission parameters. These definitions may be used
* for defining attributes of transmission-related managed object classes
* of the NML-EML interface (such as termination points and subnetwork
* connections), which specify these transmission characteristics
* for the application-specific MOC to be defined.</p>
*
* <p>Whilst the framework can be applied for the modelling of any OS-OS
* interface in a service-oriented way, a particularly important application
* is the case of an NMS-EMS interface where the EMS is in contact with a
* physical telecom network that may encompass a number of transport, access
* and aggregation technologies. The framework therefore provides a generic
* and flexible means to model any of these network technologies down to any
* required detail and in the context of protocol stacks and multiplexing
* hierarchies. This approach is called <b>multi-technology capability</b>
* for short and is based on the layered transport network functional
* architecture of Recommendations G.805 and G.809, and the corresponding
* management abstractions provided in Recommendation G.852.2.</p>
**/
module transmissionParameters
{
/**
* <p>The LayerRate_T value is used to identify the characteristic or
* adapted information of a telecom transmission layer according to Rec.
* G.805 (and Rec. G.809). Managed object class definitions for entities,
* whose features depend on such layer(s), may include an attribute of
* this type, or a list of this type, to identify the supported or
* provisioned Layer rate(s). For example:<br>
* - the list of layers at which an NE may establish cross-connects;<br>
* - the (connectable) layer of a TTP or CTP
* (as defined by Rec. G.852.2 and Rec. M.3100);<br>
* - the Layer rate of a subnetwork connection.</p>
*
* <p>The type of the LayerRate_T has been made a <code>short</code>
* rather than an (extensible) <code>enum</code> to allow new rates to
* be added without changing the IDL interface. This generic framework
* for OS-OS interface design does not encode specific Layer rates,
* however, but leaves this task to domain-specific applications and
* extensions. In the interest of interoperability users of the
* service-oriented CORBA framework must cooperate in reaching
* normative usage of standardised Layer rates (and associated
* transmission parameters) (see 8.4/X.780.2).</p>
*
* <p>The value 0 is not used, and the value 1 is identified as
* LR_Not_Applicable and used in cases where a Layer rate attribute is
* not applicable. A Layer rate in the range 0 to 9999 is considered
* as a <b>standardised Layer rate</b>, while the range of numbers 10.000
* and above is allocated for vendor-specific usage and a Layer rate in
* this range is considered as a <b>proprietary Layer rate</b>.</p>
**/
typedef short LayerRate_T;
/**
* <p>Set of LayerRate_T. The LayerRateList_T struct represents
* multiple layers according to client/server relationships between
* adjacent layers as specified in Recs. G.805 and G.809.</p>
**/
typedef sequence<LayerRate_T> LayerRateList_T;
/**
* <p>The LayeredParameters_T struct includes the Layer rate with
* the applicable list of transmissions parameters. It may be used
* to define attributes of single-layered managed entities.</p>
*
* <p>LayerRate_T <b>layer</b>:
* Represents the layer to which the parameters apply.<br>
*
* globaldefs::NVSList_T <b>transmissionParams</b>:
* Name/value pair list for the supported Layer rates as specified in
* applications and extensions of this framework (see 8.4/X.780.2).</p>
**/
struct LayeredParameters_T
{
LayerRate_T layer;
globaldefs::NVSList_T transmissionParams;
};
/**
* <p>Set of LayeredParameters_T. It may be used for defining
* attributes of multi-layered managed entities.</p>
**/
typedef sequence<LayeredParameters_T> LayeredParameterList_T;
}; // end of module
/**
A.4 Module notifications
*/
/**
* <p>This module contains the definition of the notification portions
* of the NML-EML interface. Refer to clause 8.3 of Rec. Q.816.2 for
* details on how this interface uses the OMG Notification Service.</p>
*
* <p>The standard notification types supported by this framework are
* listed as constants. For each standard notification type a struct
* is defined that groups all attributes of this type.</p>
*
* <p>An interface specification that extends this framework may define
* additional notification/event types according to the rule
* <code>const string NT_<notification type> =
* "NT_<notification type>";</code>.
* It may also refine the standard notification types with additional
* field attributes. In this context it is also allowed to refactor
* definitions from this module to other CORBA modules (e.g.,
* when defining PM details in a separate PM module).</p>
*
* <p>The NMS should ignore notifications with unrecognised event type.
* This is required to provide forward compatibility.</p>
**/
module notifications
{
/** Object Creation Notification (OCN) */
const string NT_OBJECT_CREATION = "NT_OBJECT_CREATION";
/** Object Deletion Notification (ODN) */
const string NT_OBJECT_DELETION = "NT_OBJECT_DELETION";
/** Attribute Value Change notification (AVC) */
const string NT_ATTRIBUTE_VALUE_CHANGE = "NT_ATTRIBUTE_VALUE_CHANGE";
/** State Change Notification (SCN) */
const string NT_STATE_CHANGE = "NT_STATE_CHANGE";
/** File Transfer Status notification (FTS) */
const string NT_FILE_TRANSFER_STATUS = "NT_FILE_TRANSFER_STATUS";
/** Backup Status Event notification (BSE) */
const string NT_BACKUP_STATUS = "NT_BACKUP_STATUS";
/** Heartbeat Event notification (HBE) */
const string NT_HEARTBEAT = "NT_HEARTBEAT";
/** Alarm notification (ALM) */
const string NT_ALARM = "NT_ALARM";
/** Threshold Crossing Alert notification (TCA) */
const string NT_TCA = "NT_TCA";
/**
* <p>The structure of any notification is an <b>OMG Structured Event</b>.</p>
*
* <p>This module defines the attributes of each standard notification
* type through an appropriate struct in order to fix all standard
* details in a compilable way (OCN_T, ODN_T, AVC_T, SCN_T, FTS_T,
* BSE_T, HBE_T, ALM_T, TCA_T). All definitions are specialisations
* of Structured Events. They shall be used for all transport mechanisms
* such as push/pull model and structured/typed events (see 6.5/Q.816.2,
* 8.3/Q.816.2, and conformance point 4) of 10.2.1/Q.816.2).</p>
*
* <p>In particular, when name/value pairs are used to define the fields of
* the filterable event body of Structured Events, the field names shall be
* the names of the record members of the struct defining the notification
* type and the actual field types shall be the types of these record members,
* except possibly when such a type is itself a struct in which case the
* record members of the nested struct shall be considered directly (e.g.,
* in case of AlarmId_T for ALM_T).</p>
**/
typedef CosNotification::StructuredEvent Event_T;
/**
* <p>A list of OMG Structured Events. This is the <b>OMG Event Batch</b>.</p>
**/
typedef sequence<CosNotification::StructuredEvent> EventList_T;
/**
* <p>The <b>eventType</b> of a notification is part of the fixed
* event header. It consists of the <b>domain_name</b> and the
* <b>type_name</b> (see 8.3/Q.816.2). The values of domain_name
* are defined by the interface specification that extends this
* framework. The values of type_name are the constants
* <code>NT_<notification type></code> (standard,
* as defined above, or implementation-specific) that specify
* the notification types used at the interface.</p>
**/
typedef CosNotification::_EventType EventType_T;
/**
* <p>To comply with the OMG definition of the fixed event header of
* structured events, each notification has a record member <b>eventName</b>
* of type string, which is meant to name a specific instance of an
* OMG structured event where the semantics of the names is defined
* by the end users of the Notification Service (i.e., the managed and
* managing systems). For reasons of interoperability it is recommended
* to ignore this field respectively to have it always set to "".</p>
**/
typedef string EventName_T;
/**
* <p>Each notification has a record member <b>notificationId</b> of type
* string, which maps to a field of the filterable event body of structured
* events and contains an implementation-defined free format notification
* identifier whose semantics is specified in 8.1.2.8/X.733. The
* uniqueness and the sequence of the notification ID are not guaranteed.
* When correlation of notifications according to Rec. X.733 is supported
* (see below), notification IDs must be chosen to be unique across all
* notifications from a particular managed object throughout the time
* the considered correlations are significant. Therefore notification IDs
* may be reused only when no requirements exist for correlating prior
* notifications and should be chosen to ensure uniqueness over as long
* a time as is feasible for the managed system (EMS).</p>
**/
typedef string NotificationId_T;
/**
* <p>Most notification types have a record member <b>objectName</b> of
* type globaldefs::NamingAttributes_T, which uniquely identifies the
* managed object that reports the event (i.e., the event source).</p>
**/
typedef globaldefs::NamingAttributes_T ObjectName_T;
/**
* <p>ObjectType_T is the type of the filterable field attribute
* <b>objectType</b>, which belongs to all notifications that are reported
* by a managed object. Standardised interface specifications that
* extend this framework shall define an objectType value for each managed
* object class that is modelled at the interface (by extending the
* common::Common_T structure - see 8.5/X.780.2). All standard notification
* types, except FTS and BSE, have this attribute. The enum
* avoids any uncertainty in the type of object and allows simple filtering.
* It cannot be extended in a backward compatible way, however.</p>
*
* <p>A notification must be reported against the correct object type,
* if this object type is modelled at the interface.</p>
*
* <p>The standard object type OT_EMS represents the managed system (EMS).</p>
*
* <p>An interface specification that extends this framework may define
* additional object types according to the rule
* <code>OT_<object type></code> where
* <code><object type></code> is an acronym or a short phrase
* that describes the object type and may consists only
* of capital letters and underscores.</p>
*
* <p>For alarms, the object type value OT_AID denotes an Alarm Identifier
* (AID) and is used to represent the EMS object types that are not modelled
* (at the interface) but can emit alarms. Other notification types should
* not be reported against AIDs. But this object type value shall also
* be used for potential new object types in future releases in order to
* guarantee backward compatibility of the interface.</p>
**/
enum ObjectType_T
{
OT_EMS,
// OT_<object type>, for each object type supported by a standardised
// interface specification that extends this framework
OT_AID
};
/**
* <p>The ObjectTypeQualifier_T is used to identify object types of
* future releases of standardised interface specifications that extend
* this framework. It is needed because the ObjectType_T enum, once
* specified for a particular release of an interface specification,
* cannot be extended for backward compatibility reasons.</p>
*
* <p>So when backward compatibility is required (as usual – see
* 10.5/X.780.2), the enum ObjectType_T cannot be extended to include
* future new object types. Therefore OT_AID is used as an "escape
* value" for the field objectType. Thus OT_AID may also represent
* new object types. To identify which object type applies, the
* filterable field attribute <b>objectTypeQualifier</b> is introduced,
* which is of type string and whose values are as follows:<br>
* <ul><li><code>""</code> indicates an AID;</li>
* <li><code>"OT_"<object type></code> where
* <object type> identifies a new object type.</li></ul></p>
*
* <p>If objectTypeQualifier is not present but objectType
* has the value OT_AID, we are dealing with a proper AID.</p>
**/
typedef string ObjectTypeQualifier_T;
/**
* <p> Most notification types have a record member <b>emsTime</b>
* of type globaldefs::Time_T, which holds the time at which the event
* was reported by the managed system (EMS).</p>
**/
typedef globaldefs::Time_T EmsTime_T;
/**
* <p> Most notification types have a record member <b>neTime</b>
* of type globaldefs::Time_T, which holds the time provided by the NE
* with the notification if the NE reports time, and is optional
* or "" otherwise.</p>
**/
typedef globaldefs::Time_T NeTime_T;
/**
* <p> Most notification types have a record member <b>edgePointRelated</b>
* of type boolean, which is TRUE if the event relates to a TP that is
* an edge point or to a managed object that is related to an edge TP,
* and is FALSE or optional otherwise (i.e., may be not present).</p>
**/
typedef boolean EdgePointRelated_T;
/**
A.4.1 OCN, ODN, AVC, SCN, FTS, BSE and HBE notifications
*/
/**
* <p>Defines the OCN notification type. Holds details of the managed
* object which is being created.</p>
*
* <p>The record member <b>remainderOfBody</b> is mapped to the
* remaining event body of the OMG structured event and holds a
* copy of the object which has been created; its actual type
* depends on the value of objectType (and objectTypeQualifier)
* and is then the struct defining the specified objectType
* (which extends common::Common_T - see 8.5/X.780.2).</p>
**/
struct OCN_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T objectName;
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
any remainderOfBody;
};
/**
* <p>Defines the ODN notification type. Holds details of the managed
* object which is being deleted.</p>
**/
struct ODN_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T objectName;
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
};
/**
* <p>The NameAndAnyValue_T structure is used when an any value is
* needed to represent a general property of a notification (i.e.,
* the recommended globaldefs::NameAndStringValue_T cannot be used
* for the property) (see also 8.2/X.780.2).</p>
**/
struct NameAndAnyValue_T
{
string name;
any value;
};
/**
* <p>A list of (name=string, value=any) tuples. It is equivalent to
* the NVList standard defined by the OMG to represent lists of general
* properties (see also globaldefs::NVSList_T for properties with string
* values). It is used for AVC, SCN and ALM notifications.</p>
*
* <p>In an AVC or SCN notification, the transmissionParams attribute’s
* value may not contain the complete value of the attribute. Rather,
* it only indicates transmission parameters that have changed. The
* value always contains a complete list of the Layer rates; but for
* each layer, only those transmission parameters that have been deleted,
* changed, or added are specified. A deleted transmission parameter is
* indicated by a "-" value; a changed or added transmission parameter
* has its new value specified. All transmission parameters not listed
* have not changed.</p>
*
* <p>Similarly in an AVC or SCN notification, the additionalInfo
* attribute’s value may not contain the complete value of the
* attribute. Rather, it only indicates NameAndStringValue_Ts that
* have been deleted, changed, or added. A deleted NameAndStringValue_T
* is indicated by a "-" value; a changed or added NameAndStringValue_T
* has its new value specified. All NameAndStringValue_Ts not listed
* have not changed.</p>
**/
typedef sequence<NameAndAnyValue_T> NVList_T;
/**
* <p>Defines the AVC notification type. Holds details of the attribute
* values of a managed object that have changed.</p>
**/
struct AVC_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T objectName;
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
NVList_T attributeList;
};
/**
* <p>Defines the SCN notification type. Holds details of the state
* attribute values of a managed object that have changed.</p>
**/
struct SCN_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T objectName;
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
NVList_T attributeList;
};
/**
* </p>Describes the file transfer (FT) status.</p>
*
* <p>The FT status values are defined as follows:
* <ul><li><b>FT_IN_PROGRESS</b>: The EMS notifies that
* the FT is in progress including the percentage of
* completion (in the range 0..100).</li>
* <li><b>FT_FAILED</b>: The EMS notifies that the FT
* has failed including the failure reason and, optionally,
* the percentage of completion.</li>
* <li><b>FT_COMPLETED</b>: The EMS notifies that
* the FT is 100 % completed.</li></ul></p>
*
* <p>The number and rate of FTS notifications indicating FT_IN_PROGRESS
* is implementation-defined, and may be zero. However, for each FT
* process initiated (directly or indirectly) by the EMS there shall be
* either an FTS with FT_COMPLETED or an FTS with FT_FAILED.</p>
**/
enum FileTransferStatus_T
{
FT_IN_PROGRESS,
FT_FAILED,
FT_COMPLETED
};
/**
* <p>Defines the FTS notification type. Holds details of a
* file transfer (FT) process.</p>
*
* <p>string <b>fileName</b>:<br>
* The name of the file being transferred including the path name
* and exactly as specified when the FT request was initiated.<br>
*
* FileTransferStatus_T <b>transferStatus</b>:<br>
* Holds the FT status value.
*
* short <b>percentComplete</b>:<br>
* Indicates percentage of FT completion in the range 0..100.<br>
*
* string <b>failureReason</b>:<br>
* Indicates the failure reason in case of FT_FAILED.</p>
**/
struct FTS_T
{
EventType_T eventType;
string eventName;
string notificationId;
string fileName;
FileTransferStatus_T transferStatus;
short percentComplete;
string failureReason;
};
/**
* <p>This enum identifies the status of a managed element with
* respect to the current database backup operation. Initially
* when the EMS is started the Current Operational Status (COS)
* will be set to COS_Idle.</p>
*
* <p>The current operational status values are defined as follows:
* <ul><li><b>COS_Idle</b>: No database backup operation has been
* performed since the EMS last (re)started (booted).</li>
* <li><b>COS_Pending</b>: A backup operation has been requested
* but has not yet started.</li>
* <li><b>COS_InProgress</b>: A backup operation is being performed.</li>
* <li><b>COS_Completed</b>: Last backup operation was successful.</li>
* <li><b>COS_Aborted</b>: Last backup operation failed.</li></ul></p>
**/
enum Current_OperationStatus_T
{
COS_Idle,
COS_Pending,
COS_InProgress,
COS_Completed,
COS_Aborted
};
/**
* <p>This data structure identifies the status of backup operation
* for a managed element. The failure reason should be present if the
* operation status indicates a failure (i.e., in Abort status).</p>
*
* <p>Current_OperationStatus_T <b>opStatus</b>:<br>
* Indicates the current operational status of the backup.<br>
*
* <br>string <b>failureReason</b>:<br>
* A free form text string provided if the opStatus value is COS_Aborted
* to explain the reason for the abort (e.g., "Comms loss with NE").</p>
**/
struct BackupStatus_T
{
Current_OperationStatus_T opStatus;
string failureReason;
};
/**
* <p>Defines the BSE notification type. Holds details of a change
* to a network element’s backup status.</p>
**/
struct BSE_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T meName;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
BackupStatus_T backupStatus;
};
/**
* <p>Defines the HBE notification type. Holds details of an
* EMS heartbeat notification. The value of the record member
* objectType is always OT_EMS.</p>
*
* <p> Refer to 7.2.5/Q.816.2, 9.1.1/Q.816.2 and 7.5/Q.816
* for information on how this interface may be used or extended
* to offer a heartbeat service (Q.816.2 Session Service
* or Q.816 Heartbeat Service).</p>
**/
struct HBE_T
{
EventType_T eventType;
string eventName;
string notificationId;
globaldefs::NamingAttributes_T objectName;
ObjectType_T objectType;
globaldefs::Time_T emsTime;
};
/**
A.4.2 ALM and TCA notifications
*/
/**
* <p>ALM and TCA notifications have an optional record member
* <b>nativeEMSName</b> of type string which represents the name of
* the managed object, which emitted the alarm resp. which is the
* measurement point whose threshold (of one of its PM parameters) has
* been crossed, as presented on the EMS GUI. The native EMS name
* attribute of a managed object is owned by the EMS which may or
* may not support changing this value (see 8.5/X.780.2).</p>
**/
typedef string NativeEMSName_T;
/**
* <p>PerceivedSeverity_T values are consistent with the definitions
* of Recs. X.733 and X.721. Refer to clause 8.1.2.3 of Rec. X.733 and
* Rec. X.733/Cor.2 for the semantics of the values. Alarms and TCAs
* have a mandatory attribute <b>perceivedSeverity</b> of this type.</p>
*
* <p>The Perceived severity levels provide an indication of how it is
* perceived that the capability of a managed object reporting an alarm
* or a TCA has been affected. Four levels represent service affecting
* (SA) or non-service affecting (NSA) conditions according to the
* determination by the managed system (EMS) (see ServiceAffecting_T):
* as stated by Rec. X.733, usually PS_CRITICAL and PS_MAJOR are SA and
* require immediate resp. urgent corrective action, while usually PS_MINOR
* and PS_WARNING are NSA resp. potentially SA and require corrective
* resp. diagnostic action. The semantics of the PS_CLEARED severity
* level depends on the values of the x733_SpecificProblems and
* x733_CorrelatedNotifications field attributes (if present).</p>
*
* <p>In case of a TCA the perceivedSeverity attribute mainly serves as
* the trigger flag, i.e. allows to distinguish between a trigger/raise
* TCA (value PS_INDETERMINATE or, optionally, some SA or NSA level)
* and a clear TCA (value PS_CLEARED).</p>
**/
enum PerceivedSeverity_T
{
PS_INDETERMINATE,
PS_CRITICAL,
PS_MAJOR,
PS_MINOR,
PS_WARNING,
PS_CLEARED
};
/**
* <p>List of PerceivedSeverity_T values.</p>
**/
typedef sequence<PerceivedSeverity_T> PerceivedSeverityList_T;
/**
* <p>ServiceAffecting_T describes the impact of a fault on monitored
* managed entities on further providing their service, as determined
* by the managed system (EMS). Alarms have a mandatory record member
* <b>serviceAffecting</b> of this type. The following SA values are defined:
*
* <ul><li><b>SA_UNKNOWN</b>: The EMS cannot determine whether
* the condition affects service or does not.</li>
*
* <li><b>SA_SERVICE_AFFECTING</b>: The EMS determines that the condition
* affects service (e.g., interrupts payload traffic).</li>
*
* <li><b>SA_NON_SERVICE_AFFECTING</b>: The EMS determines that
* the condition does not affect service.</li></ul></p>
**/
enum ServiceAffecting_T
{
SA_UNKNOWN,
SA_SERVICE_AFFECTING,
SA_NON_SERVICE_AFFECTING
};
/**
* <p>Each alarm (ALM notification) has an optional record member
* <b>affectedTPList</b> of type globaldefs::NamingAttributesList_T which
* holds a list of affected TPs (ordered by TP names). It shall indicate
* in case of alarms on equipment the physical TPs (ports) implemented
* by the alarmed equipment and affected by the equipment failure
* (irrespective of whether the alarm is service affecting or not).</p>
**/
typedef globaldefs::NamingAttributesList_T AffectedTPList_T;
/**
* <p>Alarms have a mandatory record member <b>probableCause</b> of type
* string which defines further qualification as to the Probable cause
* of the alarm in the sense of Rec. X.733. Probable causes are used
* to classify alarm types.</p>
*
* <p>The framework does not encode specific Probable causes but
* any OS-OS interface specification that extends this framework
* shall specify all Probable causes that may occur according to
* the rules laid down in 8.7.3.1/X.780.2 "Probable causes"
* (e.g., "AIS" for Alarm Indication Signal, "BER_SD"
* for Bit Error Rate Signal Degrade).</p>
*
* <p>For example, Recs. X.733 and X.721 define 57 Probable causes,
* Rec. M.3100 defines or reserves 207 Probable causes that partly
* overlap with the X.733/X.721 definitions, and TM Forum’s MTNM v3.0
* defines 96 Probable cause strings (see 8.7.3.1/X.780.2).</p>
*
* <p>Refer to the standardised OS-OS interface specifications
* that extend this framework for the normative specification and
* description of the Probable cause strings available with the
* respective release of the interface.</p>
**/
typedef string ProbableCause_T;
/**
* <p>Set of Probable causes. This type may be used, for example,
* in case of on-demand pulling of alarms in order to include
* or exclude specified Probable causes.</p>
**/
typedef sequence<string> ProbableCauseList_T;
/**
* <p>Alarms have an optional record member <b>probableCauseQualifier</b>
* of type string which is meant to be used together with objectName,
* layerRate and probableCause to fully and uniquely identify the alarm.
* If this attribute is an empty string (or not present in the OMG
* Structured Event), the other three attributes must provide
* uniqueness. Otherwise this attribute contains information such that
* any clear of that alarm would correlate to the correct alarm.</p>
**/
typedef string ProbableCauseQualifier_T;
/**
* <p>Alarms have an optional record member <b>nativeProbableCause</b>
* of type string which shall represent the value of the Probable cause
* as portrayed on the EMS user interface.</p>
**/
typedef string NativeProbableCause_T;
/**
* <p>The relationship between Probable causes and Perceived severities
* (and Service affection) as reported by ALM notifications is fundamental
* for alarm management. Therefore the advance assignment of severities to
* Probable causes per managed object (having regard to Service affection)
* is of interest. For this purpose the concepts of Assigned severity and
* Alarm Severity Assignment (ASA) are introduced for SA, NSA and service
* independent usage (as determined by the managed system (EMS)).</p>
*
* <p>AssignedSeverity_T adapts PerceivedSeverity_T for managed
* object-specific advance severity assignments to Probable causes.
* Its values are consistent with the AlarmSeverityCode definition
* of Rec. M.3100.</p>
*
* <p>The Assigned severity values are defined as follows:
*
* <ul><li>AS_INDETERMINATE: The Indeterminate level indicates that
* the assigned severity level cannot be determined.</li>
*
* <li>AS_CRITICAL: The Critical level indicates that a usually
* SA condition has occurred and an immediate corrective action
* is required. Such a severity can be assigned, for example,
* when an object would become totally out of service and its
* entire capability must be restored.</li>
*
* <li>AS_MAJOR: The Major level indicates that a usually SA condition
* has developed and an urgent corrective action is required. Such a
* severity can be assigned, for example, when there would be a severe
* degradation in the capability of the managed object and therefore
* its full capability need be restored.</li>
*
* <li>AS_MINOR: The Minor level indicates the existence of a usually NSA
* fault condition and that corrective action should be taken in order
* to prevent a more serious (e.g., SA) fault. Such a severity can be
* assigned, for example, when the detected alarm condition would not
* currently degrade the capacity of the managed object.</li>
*
* <li>AS_WARNING: The Warning level indicates the detection of a
* usually potential or impending SA 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 (e.g., SA) fault.</li>
*
* <li>AS_NONALARMED: The Nonalarmed level indicates that no alarm
* should be raised.</li>
*
* <li>AS_FREE_CHOICE: The Free choice level indicates that the managed
* system (EMS) or network element is free to make a choice of the
* Perceived severity level based upon its local criteria.</li></ul></p>
**/
enum AssignedSeverity_T
{
AS_INDETERMINATE,
AS_CRITICAL,
AS_MAJOR,
AS_MINOR,
AS_WARNING,
AS_NONALARMED,
AS_FREE_CHOICE
};
/**
* <p>AlarmSeverityAssignment_T provides an Alarm Severity Assignment
* (ASA), or rather three ASAs, to be used for managed object-specific
* assessment of faults (which is out of scope of this framework).
* It defines three values for severity to cover the cases of service
* affecting conditions, non-service affecting conditions, and conditions
* where the service impact is unknown. The structure fully identifies
* the specific alarm type that it applies to by using the three available
* Probable cause identifiers in combination. It is consistent with
* the AlarmSeverityAssignment definition of Rec. M.3100.</p>
*
* <p>string <b>probableCause</b>:<br>
* The Probable cause of the alarm to which the severities are assigned.
* This is a normative string defined by the interface specification.<br>
*
* <br>string <b>probableCauseQualifier</b>:<br>
* A qualifier of the Probable cause that is used to achieve uniqueness
* in such cases where the Probable cause alone would not be sufficient.
* This is a free format string which often is empty.<br>
*
* <br>string <b>nativeProbableCause</b>:<br>
* The Probable cause representation as used on the user interface of
* the managed system (EMS) or network element. This is a human-readable,
* implementation-defined free format string.<br>
*
* <br>AssignedSeverity_T <b>serviceAffecting</b>:<br>
* Severity assigned to the Probable cause when service affecting.<br>
*
* <br>AssignedSeverity_T <b>serviceNonAffecting</b>:<br>
* Severity assigned to the Probable cause when not service affecting.<br>
*
* <br>AssignedSeverity_T <b>serviceIndependentOrUnknown</b>:<br>
* Severity assigned to the Probable cause when the service impact is
* not known or is known to be service independent.</p>
**/
struct AlarmSeverityAssignment_T
{
string probableCause;
string probableCauseQualifier; // OPTIONAL
string nativeProbableCause; // OPTIONAL
AssignedSeverity_T serviceAffecting;
AssignedSeverity_T serviceNonAffecting;
AssignedSeverity_T serviceIndependentOrUnknown;
};
/**
* <p>AlarmSeverityAssignmentList_T provides a listing of all abnormal
* conditions that may exist in instances of a managed object class. Each
* element of this sequence specifies a Probable cause and, optionally,
* a probableCauseQualifier and/or a nativeProbableCause as well as
* the three severities to be assigned to the Probable cause.</p>
**/
typedef sequence<AlarmSeverityAssignment_T> AlarmSeverityAssignmentList_T;
/**
* <p>Alarms have an optional record member <b>additionalText</b> of type
* string which allows, in an X.733-consistent way, a free form text
* description to be reported in order to convey additional textual
* information on the alarm. Such information can range from a simple note
* (e.g., "Unit is mismounted") to an entire notepad (e.g., details of
* event acknowledgement or clearance such as note priority/time/text
* and the user name of the attending operator).</p>
**/
typedef string AdditionalText_T;
/**
* <p>Alarms have an optional record member <b>additionalInfo</b> of type
* globaldefs::NVSList_T which allows, according to stringification
* conventions, the communication from the EMS to the NMS of additional
* information that is not explicitly modelled (e.g., any X.733-specified
* details that are not yet covered otherwise) (see also 8.5/X.780.2).</p>
**/
typedef globaldefs::NVSList_T AdditionalInfo_T;
/**
* <p>Alarms have a mandatory record member <b>rcaiIndicator</b> of
* type boolean which shall indicate whether the alarm is a raw,
* i.e. uncorrelated, alarm (default situation) or a root cause alarm
* indication (RCAI).</p>
**/
typedef boolean RcaiIndicator_T;
/**
* <p>ALM and TCA notifications have a mandatory record member
* <b>isClearable</b> of type boolean which is an indication as to
* whether a raise/trigger event will have an associated clear event
* or the event is a clear itself. If an ALM or TCA clear event is
* generated in case of clearance then the raise/trigger event
* is defined to be clearable.</p>
**/
typedef boolean IsClearable_T;
/**
* <p>AcknowledgeIndication_T describes the event acknowledgement
* indication. Active and cleared ALM and TCA notifications have
* an optional record member <b>acknowledgeIndication</b> of this type.
* Refer to section 3.7 of the OMG Notification Service specification
* regarding support of event acknowledgement based on sequence numbers
* that allow (together with QoS properties) for reliable event delivery
* and are conveyed in the variable event header. Refer to clause
* 8.7.5.3 "Event acknowledgement" of Rec. X.780.2 for a description of
* how to use these sequence numbers or the ALM and TCA identifiers
* (see AlarmId_T and TCAId_T) for event acknowledgement.</p>
*
* <p>AI_EVENT_ACKNOWLEDGED: Used in case the event has been
* acknowledged in the managed system (EMS), or in case the event
* has been previously acknowledged and has now been requested to
* be unacknowledged but the EMS is unable to do so. All event
* fields other than emsTime and acknowledgeIndication shall
* remain similar to the original ALM or TCA notification.
* The emsTime is always provided as the time that the event
* acknowledgement notification has been reported by the EMS.<br>
*
* <br>AI_EVENT_UNACKNOWLEDGED: Used in case the event has not (yet)
* been acknowledged in the managed system but the EMS supports
* acknowledgement for this event, or in case the event has been
* previously acknowledged and has now been unacknowledged.
* In this case all event fields other than emsTime shall
* remain similar to the original ALM or TCA notification.
* The emsTime is always provided as the time that the event
* (un)acknowledgement notification has been reported by the EMS.<br>
*
* <br>AI_NA: Used in case the EMS does not support acknowledgement for
* this event or does not support acknowledgement at all.</p>
**/
enum AcknowledgeIndication_T
{
AI_EVENT_ACKNOWLEDGED,
AI_EVENT_UNACKNOWLEDGED,
AI_NA
};
/**
* <p>The alarm definition of the service-oriented framework provides
* means to allow for conveyance of fully X.733-compliant alarms resp.
* of all X.733-specified details that a managed system (EMS) may
* offer to managing systems (NMSes) (see 8.7.3.3/X.780.2
* "Coding of X.733 alarm information" for a concise overview).</p>
*
* <p>The <b>Threshold information</b> parameter of the X.733/X.721
* alarm record is not present in the alarm definition of this framework
* since threshold crossings are not reported by alarm notifications
* but by TCA notifications (see TCA_T). Refer to clause 8.7.3.3 "Coding
* of X.733 alarm information" of Rec. X.780.2 for the mapping of X.733
* Threshold information to TCA event attributes.</p>
*
* <p>The <b>x733_EventType</b> attribute of type string specifies the
* type of ITU-T event being reported where the semantics is defined in
* Recs. X.710 and X.733 and the ITU-T syntax in Rec. X.711. As part
* of an alarm record it categorizes the alarm.</p>
*
* <p>Five basic ITU-T categories of an alarm are defined:<br>
*
* "communicationsAlarm" - an alarm of this type is principally
* associated with the procedures and/or processes required to convey
* information from one point to another;<br>
*
* "qualityofServiceAlarm" - an alarm of this type is principally
* associated with a degradation in the quality of a service;<br>
*
* "processingErrorAlarm" - an alarm of this type is principally
* associated with a software or processing fault;<br>
*
* "equipmentAlarm" - an alarm of this type is principally
* associated with an equipment fault;<br>
*
* "environmentalAlarm" - an alarm of this type is principally
* associated with a condition relating to an enclosure
* in which the equipment resides.</p>
*
* <p>The X.730-series Recommendations define further notification
* types whose GDMO definitions and ASN.1 productions are summarized
* in Rec. X.721: objectCreation, objectDeletion, attributeValueChange,
* stateChange, relationshipChange, and five security violation event
* types. They correspond to the CORBA notification types defined
* in Rec. X.780 which are encoded in the type_name field of the fixed
* event header of OMG structured events as are the notification types
* of this framework (see 8.5/Q.816.2 and 8.7/X.780.2).</p>
*
* <p>Rec. X.733 includes informative recommendations for the mapping
* of each defined Probable cause to one of the five alarm event types.
* For example, thresholdCrossed is mapped to qualityofService. This
* alarm is dealt with as the separate event type TCA by this framework
* (see TCA_T for details). Similarly Rec. M.3100 groups the defined
* and reserved Probable causes according to the alarm event types.</p>
**/
typedef string X733_EventType_T;
/**
* <p>The <b>x733_EventTime</b> attribute contains the time of generation
* of the alarm. Its type is a generalized time (see globaldefs::Time_T).
* This may be equal to one of the attributes emsTime or neTime.
* The definition complies with the syntax and semantics of
* Recs. X.710 and X.721.</p>
**/
typedef globaldefs::Time_T X733_EventTime_T;
/**
* <p>Element of SpecificProblemList_T (see below), i.e. a clarification of
* the Probable cause of an alarm. It is designed to be human-readable and
* compatible with ITU-T usage and semantics as defined by Rec. X.733.</p>
**/
typedef string SpecificProblem_T;
/**
* <p>List of SpecificProblem_T values. When present in an alarm, it
* identifies further refinements to the Probable cause of the alarm.
* The optional <b>x733_SpecificProblems</b> field attribute uses that type.
* It fully qualifies the chosen Probable cause and may be used to specify,
* in an X.733-consistent way, a set of Specific problems for use in
* managed object classes that emit alarms with that Probable cause.</p>
*
* <p>When stringified (e.g., through separation of the elements
* of the list by a slash character "/"), it corresponds to the
* probableCauseQualifier.</p>
**/
typedef sequence<SpecificProblem_T> SpecificProblemList_T;
/**
* <p>The <b>x733_BackupStatus</b> attribute of type string specifies whether
* or not the managed object emitting the alarm has been backed-up, and
* services provided to the user have, therefore, not been disrupted.
* If the value is "BACKED_UP", it indicates that the object emitting
* the alarm has been backed-up, if "NOT_BACKED_UP", the object has not
* been backed-up. The use of this field in conjunction with the
* perceivedSeverity field provides information in an independent form
* to qualify the seriousness of the alarm and the ability of the managed
* system (EMS) as a whole to continue to provide services.</p>
**/
typedef string X733_BackupStatus_T;
/**
* <p>The <b>x733_BackupObject</b> attribute specifies, when x733_BackupStatus
* is "BACKED_UP", the (name of the) managed object instance that is providing
* back-up services for the managed object about which the alarm pertains.
* This attribute is useful, for example, when the back-up object is from
* a pool of managed objects any of which may be dynamically allocated
* to replace a faulty managed object.</p>
**/
typedef globaldefs::NamingAttributesList_T X733_BackupObject_T;
/**
* <p>The <b>x733_TrendIndication</b> attribute of type string specifies
* the current Perceived severity trend of the managed object reporting
* the alarm. If present it indicates that there are one or more alarms
* ("outstanding alarms") which have not been cleared, and pertain to
* the same managed object as that to which this alarm ("current alarm")
* pertains. It has the three possible values "LESS_SEVERE", "NO_CHANGE",
* and "MORE_SEVERE" with the semantics defined by Rec. X.733. In order
* for x733_TrendIndication to be meaningful, the perceivedSeverity
* attribute value of each alarm that may be emitted by the considered
* managed object must be defined consistently over all of the defined
* alarm types for that managed object class.</p>
**/
typedef string X733_TrendIndication_T;
/**
* <p>List of notification IDs (i.e., values of the field attribute
* <b>notificationId</b> in the notifications).</p>
**/
typedef sequence<string> NotifIDList_T;
/**
* <p> Correlated notifications are identified by the object that emitted
* the notification and the notification IDs. Both are included in case
* the notification IDs are not unique across managed objects.</p>
*
* <p>globaldefs::NamingAttributes_T <b>source</b>:
* Reference to the managed object that emitted the correlated
* notifications. If empty, the correlated notifications are from
* the same source as the alarm containing this data structure.<br>
*
* <br>NotifIDList_T <b>notifIDs</b>:
* List of notification IDs of the correlated notifications.
* To use this structure, notification IDs must be chosen to be
* unique across all notifications from a particular managed object
* throughout the time that correlations are significant.</p>
**/
struct CorrelatedNotifications_T
{
globaldefs::NamingAttributes_T source;
NotifIDList_T notifIDs;
};
/**
* <p>List of CorrelatedNotifications_T values. The optional
* <b>x733_CorrelatedNotifications</b> field attribute uses this type.
* When present in an alarm, it contains, in an X.733-consistent way,
* a set of notification identifiers and, if necessary, their associated
* object names. This set is defined to be the set of all notifications
* to which this alarm is considered to be correlated.</p>
**/
typedef sequence<CorrelatedNotifications_T> CorrelatedNotificationList_T;
/**
* <p>The <b>x733_MonitoredAttributes</b> attribute of type NVList_T defines
* one or more attributes of the managed object and their corresponding
* values (of arbitrary type) at the time of the alarm (e.g., state or
* status attributes). This allows, for example, the timely reporting of
* changing conditions prevalent at the time of the alarm generation.</p>
**/
typedef NVList_T X733_MonitoredAttributes_T;
/**
* <p>Element of ProposedRepairActionList_T (see below), i.e. a solution
* proposed by the managed system (EMS) to a known cause of an alarm (such
* as switch in standby equipment, retry, replace media). It is designed
* to be human-readable and compatible with ITU-T usage and semantics as
* defined by Rec. X.733. Two general values are specified by Rec. X.733:
* "no repair action required" and "repair action required".</p>
**/
typedef string ProposedRepairAction_T;
/**
* <p>List of ProposedRepairAction_T values. When present in an alarm, it
* indicates that the cause of the alarm is known and the system being
* managed (EMS) can suggest one or more solutions. The optional
* <b>x733_ProposedRepairActions</b> field attribute uses this type.
* It may be used to specify, in an X.733-consistent way, a set of
* Proposed repair actions for use in managed object classes that emit
* alarms with that known (Probable) cause.</p>
**/
typedef sequence<ProposedRepairAction_T> ProposedRepairActionList_T;
/**
* <p>The <b>x733_StateChange</b> attribute of type NVList_T is an
* X.733-compliant AVC definition, i.e. it contains a series of state
* attribute identifiers and their (old and )new values that can be used
* in an SCN notification. This attribute, when present, is used to
* indicate an X.731 state transition associated with the alarm.
* In this case, if the MOC definition of the managed object emitting
* the alarm includes notifications this managed object should also
* emit an SCN as specified above.</p>
**/
typedef NVList_T X733_StateChange_T;
/**
* <p>The <b>x733_AdditionalInfo</b> attribute of type NVList_T is used
* to supply additional information in alarms. It allows the inclusion
* of a set of additional information in the alarm whose syntax and
* semantics are specified by Recs. X.721 and X.733 based on the concept
* of management extensions. The representation of the X.721/X.733
* information in the NVList_T structure is implementation-defined
* (free format).</p>
**/
typedef NVList_T X733_AdditionalInfo_T;
/**
* <p>AlarmId_T is used as a unique identifier of an alarm. It includes:</p>
*
* <p>globaldefs::NamingAttributes_T <b>objectName</b>:<br>
* The name represents the name of the managed entity that gave rise
* to the alarm. Refer to clause 10.3.2 "Structure of naming attribute
* of managed objects" of Rec. X.780.2 for further details.<br>
*
* <br>transmissionParameters::LayerRate_T <b>layerRate</b>:<br>
* Identifies the layerRate of the managed object raising the alarm.
* For objects where the layerRate is not applicable, such as EMS, the
* value is set to LR_Not_Applicable. LayerRate is applicable in alarms
* raised by objects that include transmission parameters such as TPs.<br>
*
* <br>string <b>probableCause</b>:<br>
* Identifies the type of alarm raised against the object.
* Refer to clause 8.7.3.1 of Rec. X.780.2 and the standardised interface
* specifications that extend this framework for a normative
* specification of the Probable cause strings that may occur.<br>
*
* <br>string <b>probableCauseQualifier</b>:<br>
* Is used as the final component of the unique
* identification of the alarm and is left empty where
* objectName, layerRate (if applicable) and probableCause alone
* provide a unique identification of the alarm.</p>
**/
struct AlarmId_T
{
globaldefs::NamingAttributes_T objectName;
transmissionParameters::LayerRate_T layerRate;
string probableCause;
string probableCauseQualifier; // OPTIONAL
};
/**
* <p>Defines the ALM notification type. Holds details of an alarm.</p>
*
* <p>An alarm must be reported against the correct managed object if it
* is modelled by the EMS (see ObjectType_T and ObjectTypeQualifier_T).
* Alarms against entities which are not modelled at the interface should
* still be reported using the OT_AID objectType. The EMS should ensure
* that all such virtual entities have a unique value for objectName.</p>
*
* <p>The combination of the objectName, layerRate, probableCause and
* probableCauseQualifier subfields of the alarmId field must uniquely
* identify an alarm. It is acceptable that the probableCauseQualifier
* be an empty string, provided that uniqueness (using the remaining
* three fields) is still guaranteed. Together, these four fields contain
* information such that any clear of an alarm would correlate to the
* correct alarm. This means that if an alarm is raised, cleared,
* raised again, and cleared again, and if the original clear and second
* alarm were missed, the second clear would clear the first alarm.</p>
*
* <p>The comment OPTIONAL means that the record member need not be
* present in the corresponding OMG Structured Event.</p>
*
* <p>When mapping the attribute alarmId to the filterable event body of
* the OMG Structured Event (see Event_T), each record member of AlarmId_T
* shall be mapped to a separate filterable data field. When mapping the
* x733-attributes to the filterable event body of the Structured Event,
* their name prefix shall be changed from "x733_" to "X.733::".</p>
*
* <p>For some type declarations (e.g., X.733-related ones) their unnamed
* equivalents are used. This is justified for the sake of readability
* and since ALM_T is mapped to structured events anyway.</p>
**/
struct ALM_T
{
EventType_T eventType;
string eventName;
string notificationId;
AlarmId_T alarmId;
string nativeProbableCause; // OPTIONAL
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
string nativeEMSName; // OPTIONAL
PerceivedSeverity_T perceivedSeverity;
ServiceAffecting_T serviceAffecting;
globaldefs::NamingAttributesList_T affectedTPList; // OPTIONAL
string additionalText; // OPTIONAL
globaldefs::NVSList_T additionalInfo; // OPTIONAL
boolean rcaiIndicator;
boolean isClearable;
AcknowledgeIndication_T acknowledgeIndication; // OPTIONAL
string x733_EventType; // OPTIONAL
globaldefs::Time_T x733_EventTime; // OPTIONAL
SpecificProblemList_T x733_SpecificProblems; // OPTIONAL
string x733_BackedUpStatus; // OPTIONAL
globaldefs::NamingAttributesList_T x733_BackUpObject; // OPTIONAL
string x733_TrendIndication; // OPTIONAL
CorrelatedNotificationList_T x733_CorrelatedNotifications; // OPTIONAL
NVList_T x733_MonitoredAttributes; // OPTIONAL
ProposedRepairActionList_T x733_ProposedRepairActions; // OPTIONAL
NVList_T x733_StateChange; // OPTIONAL
NVList_T x733_AdditionalInfo; // OPTIONAL
};
/**
* <p>The framework does not encode specific performance parameters
* but any interface specification that extends this framework shall
* specify all performance parameters that may occur in the normative
* form <code>"PMP_<performance measure>"</code> according to
* the rules laid down in clause 8.7.4.1 "PM parameters" of Rec.
* X.780.2 (e.g., <code>"PMP_AISS"</code> for Alarm Indication Signal
* Seconds, <code>"PMP_BER"</code> for Bit Error Rate).</p>
*
* <p>PMParameterName_T holds the name of a performance measurement
* (i.e., a performance parameter). It has been defined as a string to
* to accommodate backward compatibility and proprietary extension. TCAs
* have a mandatory attribute <b>pmParameterName</b> of this type.</p>
**/
typedef string PMParameterName_T;
/**
* <p>PMLocation_T specifies the location and orientation/direction
* for the measurement of the associated PM parameter thereby qualifying
* the traffic to be monitored, supervised and measured. It has been
* defined as a string to accommodate extensibility. TCAs have
* a mandatory attribute <b>pmLocation</b> of this type.</p>
*
* <p>PM parameters may relate to measurements taken on receive (Rx)
* or transmit (Tx) traffic either at the named TP (PML_NEAR_END_Rx/Tx)
* or at the TP at the far end of the trail/connection connected to
* the named TP (PML_FAR_END_Rx/Tx). Alternatively, the PM parameters
* may be bidirectional (PML_BIDIRECTIONAL) (e.g., resulting from a
* second by second summation and evaluation of both far and near TPs).
* Measurements may also be carried out contra-directional to the
* supervised signal (PML_CONTRA_NEAR/FAR_END_Tx).</p>
*
* <p>Valid standard values are:<br>
* "PML_NEAR_END_Rx",<br>
* "PML_FAR_END_Rx",<br>
* "PML_NEAR_END_Tx",<br>
* "PML_FAR_END_Tx",<br>
* "PML_BIDIRECTIONAL",<br>
* "PML_CONTRA_NEAR_END_Tx",<br>
* "PML_CONTRA_FAR_END_Tx".</p>
*
* <p>Refer to clause 8.7.4.2 "Location identification"
* of Rec. X.780.2 for further details.</p>
**/
typedef string PMLocation_T;
/**
* <p>Granularity_T specifies the count period resp. measurement
* period (interval or duration) for which PM data may be
* collected (and subsequently retrieved). TCAs have
* a mandatory attribute <b>granularity</b> of this type.</p>
*
* <p>The format is one of:
* <ul><li>"<i>n</i>min" (representing <i>n</i> minute granularity)
* for values of <i>n</i> that are not multiples of 60;</li>
* <li>"<i>n</i>h" (representing <i>n</i> hour granularity);</li>
* <li>"NA" (not applicable, representing instantaneous
* measurements).</li></ul></p>
*
* <p>Standard values are:<br>
* "15min",<br>
* "24h",<br>
* "NA" (for current instantaneous measurements).<br></p>
**/
typedef string Granularity_T;
/**
* <p>PMThresholdType_T describes threshold watermark (TWM) levels,
* or threshold types for short, of TCA notifications. TCAs have
* a mandatory attribute <b>thresholdType</b> of this type.</p>
*
* <p>The TWM_HIGH and TWM_HIGHEST types are used for TCAs that are
* raised when the measured value goes above the threshold. The
* TWM_LOW and TWM_LOWEST types are used for TCAs that are raised
* when the measured value goes below the threshold; they only apply
* to gauges since counters do not count down (but may wrap around).</p>
*
* <p>When there is one level of TCA notification triggers, only
* TWM_HIGH and/or TWM_LOW are used, and when there are two levels of
* TCA triggers, TWM_HIGHEST and/or TWM_LOWEST are used in addition.</p>
*
* <p>Refer to clause 8.7.4.4 "PM thresholds" of Rec. X.780.2 for
* information on how watermark levels are used for raise/trigger
* and clear TCAs. Note that the perceivedSeverity attribute (see
* PerceivedSeverity_T) serves (mainly, in case of TCAs) as the
* trigger flag (i.e., it indicates whether a TCA is a clear or
* is a trigger/raise with or without severity).</p>
**/
enum PMThresholdType_T
{
TWM_HIGHEST,
TWM_HIGH,
TWM_LOW,
TWM_LOWEST
};
/**
* <p>TCAId_T is used as a unique identifier of a threshold crossing
* alert (TCA). It includes:</p>
*
* <p>globaldefs::NamingAttributes_T <b>objectName</b>:<br>
* The name represents the name of the managed entity that gave rise
* to the TCA (i.e., the measurement point). Refer to clause 10.3.2
* "Structure of naming attribute of managed objects" of Rec. X.780.2
* for further detail on the name structure.<br>
*
* <br>transmissionParameters::LayerRate_T <b>layerRate</b>:<br>
* Identifies the layerRate of the managed object raising the TCA.
* For objects where the layerRate is not applicable, such as EMS, the
* value is set to LR_Not_Applicable. LayerRate is applicable in TCAs
* raised by objects that include transmission parameters such as TPs.<br>
*
* <br>PMParameterName_T <b>pmParameterName</b>:<br>
* Holds the name of the performance measure for which the TCA was
* raised (i.e., the subject of performance measurement).<br>
*
* <br>PMLocation_T <b>pmLocation</b>:<br>
* Holds the location and orientation of the performance measure.<br>
*
* <br>Granularity_T <b>granularity</b>:<br>
* Holds the count/measurement period of the performance measure.</p>
**/
struct TCAId_T
{
globaldefs::NamingAttributes_T objectName;
transmissionParameters::LayerRate_T layerRate;
PMParameterName_T pmParameterName;
PMLocation_T pmLocation;
Granularity_T granularity;
PMThresholdType_T thresholdType;
};
/**
* <p>TCA notifications have an optional attribute <b>value</b> of type
* float, the threshold value, which holds the value of the threshold
* (counter or gauge) that has been crossed if known.</p>
**/
typedef float Value_T;
/**
* <p>TCA notifications have an optional attribute <b>unit</b> of type
* string, the threshold unit, which holds the unit of measurement for
* the threshold value in a free format if value is present.</p>
**/
typedef string Unit_T;
/**
* <p>Defines the TCA notification type. Holds details of a Threshold
* Crossing Alert notification (TCA), which is an event used across
* the OS-OS interface to indicate that a Performance Monitoring
* (PM) parameter threshold has been crossed.</p>
*
* <p>This framework calls the X.733 alarm notification with Probable
* cause thresholdCrossed (and event type qualityofService) a Threshold
* Crossing Alert (TCA) and defines its structure independently of the
* ALM notification structure. The TCA structure and behaviour depend
* on the concepts of service-oriented Performance Management (PM)
* outlined in 8.7.4/X.780.2. TCA notifications have specific PM-related
* attributes not found in other alarms and do not need a Probable cause
* and related attributes, and ALM notifications do not provide any
* threshold information.</p>
*
* <p>The targets of PM are managed objects such as TPs which are
* called measurement points and where access points to PM activities
* are identified by certain transmission Layer rates, locations, and
* granularities. PM parameters are the subjects of PM activities on
* measurement points (such as performance monitoring, threshold
* supervision, and PM data collection) and may have associated one or
* more PM thresholds. When such a threshold is being crossed (and
* threshold supervision is activated), the measurement point emits
* a TCA notification with the characteristics of the PM parameter
* and PM threshold. Such a complete set of threshold crossing
* characteristics is called a TCA parameter (PM parameter name,
* PM location, granularity, PM threshold) and is applicable to
* one or more (or all) transmission Layer rates.</p>
*
* <p>TCA notifications are the results of threshold supervision but
* the real results of PM activities on measurement points are the PM data
* which are stored for a certain holding time as current PM data in
* collection bins according to the required granularity (e.g., 15min,
* 24h, instantaneous) and made persistent as history PM data records
* at the end of the granularity period. Currently the service-oriented
* framework only specifies the TCA-related part of PM. The definition
* of the PM data record structure and PM operations (i.e., a
* service-oriented façade for PM) is for further study.</p>
*
* <p>The combination of the objectName, layerRate, granularity,
* pmParameterName, pmLocation, and thresholdType fields must uniquely
* identify a TCA. Together, these six fields contain information
* such that any clear of a TCA would correlate to the correct TCA.
* This means that if a TCA is raised, cleared, raised again, and
* cleared again, and if the original clear and second TCA were missed,
* the second clear would clear the first TCA.</p>
*
* <p>The comment OPTIONAL means that the record member need not be
* present in the corresponding OMG Structured Event.</p>
*
* <p>When mapping the attribute TCAId to the filterable event body of
* the OMG Structured Event (see Event_T), each record member of TCAId_T
* shall be mapped to a separate filterable data field.</p>
*
* <p>For some type declarations their unnamed equivalents are used.
* This is justified for the sake of readability and since TCA_T is
* mapped to structured events anyway.</p>
**/
struct TCA_T
{
EventType_T eventType;
string eventName;
string notificationId;
TCAId_T TCAId;
ObjectType_T objectType;
ObjectTypeQualifier_T objectTypeQualifier;
globaldefs::Time_T emsTime;
globaldefs::Time_T neTime;
boolean edgePointRelated;
string nativeEMSName; // OPTIONAL
PerceivedSeverity_T perceivedSeverity;
float value; // OPTIONAL
string unit; // OPTIONAL
string additionalText; // OPTIONAL
boolean isClearable;
AcknowledgeIndication_T acknowledgeIndication; // OPTIONAL
};
/**
* <p>Used to distinguish TCA from alarm.</p>
**/
enum AlarmTypeQualifier_T
{
ALARM,
TCA
};
/**
* <p>Structure used for components of a mixed list of alarm and TCA
* identifiers. The structure is switched on AlarmTypeQualifier_T.
* The contents is either an alarm ID or a TCA ID.</p>
**/
union AlarmOrTCAIdentifier_T switch (AlarmTypeQualifier_T)
{
case ALARM: AlarmId_T alarmId;
case TCA: TCAId_T tcaId;
};
/**
* <p>Sequence of identifiers for alarms and TCAs. This allows to
* uniformly treat mixed lists of alarm and TCA identifiers, for example
* as operation parameters for acknowledge and unacknowledge purposes.</p>
**/
typedef sequence<AlarmOrTCAIdentifier_T> AlarmAndTCAIDList_T;
/**
A.4.3 Event iterator interface
*/
/**
* <p>In order to allow the NMS to deal with retrieval of a large number
* of events, iterators are used for bulk retrieval of notifications.</p>
*
* <p>Refer to clause 9.4 "Iterator interfaces" of Rec. X.780.2
* for information on how iterators are used in this interface.</p>
**/
interface EventIterator_I
{
boolean next_n(
in unsigned long how_many,
out EventList_T eventList)
raises(globaldefs::ProcessingFailureException);
unsigned long getLength()
raises(globaldefs::ProcessingFailureException);
void destroy()
raises(globaldefs::ProcessingFailureException);
}; // end of interface
}; // end of module
#endif // end of #ifndef ITUT_X780_2_IDL