multilayersubnetwork.idl

UCS (Ultra Corba Simulator) is one more powerful corba client/servant simulator tool than other simi

#ifndef multiLayerSubnetwork_idl
#define multiLayerSubnetwork_idl

// ********************************
// *                              *
// * multiLayerSubnetwork.idl     *
// *                              *
// ********************************

//Include list
#include "globaldefs.idl"
#include "transmissionParameters.idl"
#include "common.idl"
#include "subnetworkConnection.idl"
#include "managedElement.idl"
#include "topologicalLink.idl"
#include "terminationPoint.idl"

#pragma prefix "mtnm.tmforum.org"

  /** 
   * <a href=supportingDocumentation/overview.html>Overview of NML-EML interface</a>
   *
   * <p>This module contains the definition of the multiLayerSubnetwork structure
   * of the NML-EML interface.
   * It also contains the definition of the multi-layer subnetwork manager.</p>
   *
   * <h5> Version 2.1. </h5>
   **/

 
module multiLayerSubnetwork
{
  /**
   * <p> Topology_T is used to describe the subnetwork configuration. The EMS shall be
   * capable of providing a SubNetwork Connection through any physical 
   * termination point of any managed element that belongs to the Subnetwork.</p>
   *
   * The following values are supported:<br>
   * <dir>
   * TOPO_SINGLETON, which is used for a single NE (of any type) that is managed 
   *   independently of its Topological Link connectivity to other NEs. It may for 
   *   example be a member of a ring that is managed by a number of EMSes. It is
   *   acceptable for an EMS to represent all NEs as being in Singleton 
   *   subnetworks regardless of the actual network configuration.
   *   A singleton subnetwork does not contain internal topological links.<br>
   * TOPO_CHAIN, which is used to cover the case where two or more NEs
   *   are managed by the same EMS and are connected by Topological Links in
   *   a chain.<br>
   * TOPO_PSR, which is used to cover the case where two or more NEs
   *   are managed by the same EMS and are connected by Topological Links in
   *   a ring that is capable of supporting subnetwork connection protection.<br>
   * TOPO_OPEN_PSR, which is used to cover the case where two or more NEs
   *   of a PS ring (but not the entire ring) are managed by the same EMS.<br>
   * TOPO_SPRING, which is used to cover the case where two or more NEs
   *   are managed by the same EMS and are connected by Topological Links in
   *   a complete ring that supports Shared Line Protection.<br>
   * TOPO_OPEN_SPRING, which is used to cover cases where two or more NEs of an SP ring 
   *   (but not the entire ring) are managed by one EMS.<br>
   * TOPO_MESH, which is used to cover an arbitrary set of two or more NEs
   *   not covered by any other type.<br>
   * </dir>
   * <p>Composite subnetworks (i.e. containing other Subnetworks) are not
   * supported in this release of the interface.<p>
   **/

   enum Topology_T
   {
    TOPO_SINGLETON,
    TOPO_CHAIN,
    TOPO_PSR,
    TOPO_OPEN_PSR,
    TOPO_SPRING,
    TOPO_OPEN_SPRING,
    TOPO_MESH
   };


  /**
   * <p>Describes the NMS-specified EMS level of freedom when performing SNC operations.</p>
   * <p>EMSFL_CC_AT_SNC_LAYER: The EMS is allowed to create or delete cross-connections,
   * at the layer of the SNC <i>only</i>, that are or will be directly used by it.</p>
   * <p>EMSFL_TERMINATE_AND_MAP: In addition to EMSFL_CC_AT_SNC_LAYER, the EMS is allowed to
   * terminate and map or unmap and unterminate CTPs
   * to generate or eliminate CTPs that are or will be used by the SNC.</p>
   * <p>EMSFL_HIGHER_ORDER_SNCS: In addition to EMSFL_TERMINATE_AND_MAP, the EMS is allowed to
   * create or delete higher order SNCs that are or will be used to carry the SNC.</p> 
   * <p>EMSFL_RECONFIGURATION: The EMS is allowed to perform <i>any</i> operation that it considers
   * relevant, which includes reorganizing any SNC or CTP to allow the creation or activation
   * of the SNC or to make the subnetwork more efficient.</p> 
   **/
  enum EMSFreedomLevel_T
  {
   EMSFL_CC_AT_SNC_LAYER,
   EMSFL_TERMINATE_AND_MAP,
   EMSFL_HIGHER_ORDER_SNCS,
   EMSFL_RECONFIGURATION
  };

  /** 
   * <p>The MultiLayerSubnetwork structure is the abstraction 
   * offered by the EMS
   * to the NMS to represent a Subnetwork that is managed by the EMS system. 
   * In this document specification, Subnetwork and MultiLayerSubnetwork
   * are used interchangeably.</p>
   * <p>It represents a logical grouping or partitioning of
   * the managed elements in a way that is entirely determined by the
   * EMS.  A managed element may belong to more than one subnetwork, at
   * different layer rates (e.g. SDH & ATM). 
   * However, subnetworks cannot overlap at the same layer rate.</p>
   *
   * <p>The NMS does not create or delete Subnetworks, they are
   * managed by the EMS. The NMS has a handle to the Subnetworks
   * managed by the EMSes and can request the establishment or the
   * removal of connections within subnetworks.</p>
   *
   * <p>In this interface specification, the way the NMS requests services
   * on the Subnetworks, including establishment and removal of subnetwork connections,
   * is through the MultiLayerSubnetworkMgr_I.</p>
   * 
   * <p>For examples on how MultiLayerSubnetworks should be modelled see
   * <a href=supportingDocumentation/layers.pdf>layering</a>.</p>
   *
   * globaldefs::NamingAttributes_T <b>name</b>:
   * <dir>The name represents the name of the MultiLayerSubNetwork
   * which is assigned by the EMS upon creation.
   * The EMS is responsible for guaranteeing the uniqueness of the name
   * within the context of the MultiLayerSubnetworkMgr_I.
   * It is a readonly attribute.</dir>
   *
   * string <b>userLabel</b>:
   * <dir>The user label is seldom used on a singleton. However for rings
   * and meshes, the operator may choose to assign some logical name for the
   * subnetwork and the EMS may choose to display it on the GUI, so that the
   * operator has a consistent view of the managed network. This attribute can be set
   * by NMS through the Common_I interface service
   * <a href=_common.Common_I.html#common::Common_I::setUserLabel>setUserLabel</a>. 
   * It is a read/write attribute.</dir>
   *
   * string <b>nativeEMSName</b>:
   * <dir>This name of the subnetwork on the EMS GUI.
   * The nativeEMSName is defaulted to a NULL string. However, this could
   * be used by the EMS for its implementation dependent purpose.</dir>
   *
   * string <b>owner</b>:
   * <dir>The owner is provisionable by the NMS. This attribute can be set
   * by NMS through the Common_I interface service
   * <a href=_common.Common_I.html#common::Common_I::setOwner>setOwner</a>. 
   * It is a read/write attribute.</dir>
   *
   * Topology_T <b>subnetworkType</b>:
   * <dir>The subnetworkType gives a coarse view of the topology of the 
   * subnetwork.
   * It is a readonly attribute.</dir>
   *
   * transmissionParameters::LayerRateList_T <b>supportedRates</b>:
   * <dir>This attribute is a list (possibly empty) of potential Cross 
   * Connection Rates at which it is possible to make SNCs within the
   * subnetwork.
   * It is a readonly attribute.</dir>
   *
   * globaldefs::NVSList_T <b>additionalInfo</b>:
   * <dir>This attribute allows the communication from the EMS to the NMS of 
   * additional information which is not explicitly modelled.
   * This may be an empty list.
   * It is a readonly attribute.</dir>
   * <br>
   **/
  struct MultiLayerSubnetwork_T
  {
   globaldefs::NamingAttributes_T name;
   string userLabel;
   string nativeEMSName;
   string owner;
   Topology_T subnetworkType;
   transmissionParameters::LayerRateList_T supportedRates;
   globaldefs::NVSList_T          additionalInfo;
  };


  /**
   * <p>Sequence of MultiLayerSubnetwork_T objects.</p>
   **/
  typedef sequence<MultiLayerSubnetwork_T> SubnetworkList_T;


  /**
   * <p>In order to allow the NMS to deal with a large number of objects,
   * iterators are used.</p>
   * <p>See <a href=supportingDocumentation/iterators.html>iterator overview</a>
   * for information on how iterators are used in this interface.</p>
   **/

   interface SubnetworkIterator_I 
   {
      boolean next_n(in  unsigned long    how_many,
                     out SubnetworkList_T subnetworkList)
        raises (globaldefs::ProcessingFailureException);

      unsigned long getLength()
        raises (globaldefs::ProcessingFailureException);

      void destroy()
        raises (globaldefs::ProcessingFailureException);
   };


  /**
   * <p>The multiLayerSubnetworkMgr_I is used to gain access to subnetworks and
   * their operations.</p>
   *
   * <p>A handle to an instance of this interface is gained via the
   * <a href=_emsSession.EmsSession_I.html#emsSession::EmsSession_I::getManager>
   * getManager</a> operation in Manager.</p>
   **/

  interface MultiLayerSubnetworkMgr_I  : common::Common_I
  {
  /**
   * <p>This allows an NMS to request a list of the ManagedElements that
   * are associated with the specified Subnetwork.</p>
   * 
   * <p>For examples on how ManegedElements are associated with MultiLayerSubnetworks see
   * <a href=supportingDocumentation/layers.pdf>layering</a>.</p>
   *
   * <p>In order to allow the NMS to deal with a large number of objects,
   * this operation uses an iterator. See
   * <a href=supportingDocumentation/iterators.html>iterator overview</a>
   * for information on how iterators are used in this interface.</p>
   *
   * @parm globaldefs::NamingAttributes_T subnetName: Name of the subnetwork.
   * @parm unsigned long how_many: Maximum number of managed elements to return in the first batch.
   * @parm managedElement::ManagedElementList_T meList: First batch of managed elements.
   * @parm managedElement::ManagedElementIterator_I meIt: Iterator to retrieve the remaining
   * managed elements.
   * @raises globaldefs::ProcessingFailureException<dir>
   * EXCPT_INTERNAL_ERROR - Raised in case of non-specific EMS internal failure<br>
   * EXCPT_INVALID_INPUT - Raised when subnetName does not reference a multiLayerSubnetwork
   *  object<br>
   * EXCPT_ENTITY_NOT_FOUND - Raised when subnetName references an object that does not exist<br>
   * EXCPT_NE_COMM_LOSS - Raised when communications to managedElement is lost<br>
   * EXCPT_TOO_MANY_OPEN_ITERATORS - Raised when maximum number of iterators that the EMS
   *  can support has been reached.
   * </dir>
   **/
   void getAllManagedElements(
         in globaldefs::NamingAttributes_T subnetName,
         in unsigned long how_many,