cim_redundancyset.mof

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

// Copyright (c) 2005 DMTF.  All rights reserved.
// <change cr="DMTFCR012891" type = "change"> Add VendorIdentifyingInfo
// to RedundancySet </change>
// <change cr="DMTFCR01291.001" type ="add">Add VendorIdentifyingInfo
// to RedundancySet</change>
// <change cr="SysDevCR00717.001" type ="add">Remove Experimental</

// <change cr="ArchCR00066.004" type="add">Add UmlPackagePath
// qualifier values to CIM Schema.</change>
// ==================================================================
//  CIM_RedundancySet
// ==================================================================
   [UMLPackagePath ( "CIM::Core::Redundancy" ), Version ( "2.10.0" ), 
    Description (
       "A class derived from SystemSpecificCollection that is a "
       "special collection of ManagedElements. This collection "
       "indicates that the aggregated elements together provide "
       "redundancy, or that redundancy is provided via sparing. All "
       "elements collected in a RedundancySet SHOULD be instantiations "
       "of the same object class.")]
class CIM_RedundancySet : CIM_SystemSpecificCollection {

      [Description (
          "RedundancyStatus provides information on the state of the "
          "RedundancyGroup. 'Fully Redundant' (value=2) means that all "
          "of the configured redundancy is still available; 'Degraded "
          "Redundancy' (3) means that some configured elements are "
          "degraded, missing or failed but that the number of elements "
          "in the set is still greater than the minimum required "
          "('MinNumberNeeded'); 'Redundancy Lost' (4) means that "
          "sufficient configured elements are missing or failed that "
          "no redundancy is available and the next failure experienced "
          "will cause overall failure. 'Overall Failure' (5) means "
          "that there has been an overall failure of the "
          "RedundancySet."), 
       ValueMap { "0", "1", "2", "3", "4", "5" }, 
       Values { "Unknown", "DMTF Reserved", "Fully Redundant",
          "Degraded Redundancy", "Redundancy Lost", "Overall Failure" }, 
       ModelCorrespondence { "CIM_RedundancySet.MinNumberNeeded" }]
   uint16 RedundancyStatus;

      [Description (
          "TypeOfSet provides information on the type of redundancy. - "
          "N+1 (=2) indicates all members are active, are unaware and "
          "function independent of one another. However, there exist "
          "at least one extra member to achieve functionality. "
          "'Sparing' is implied (i.e. each member can be a spare for "
          "the other(s). An example of N+1 is a system that has 2 "
          "power supplies, but needs only 1 power supply to "
          "functioning properly. \n"
          "- Load Balanced (=3) indicates all members are active. "
          "However, there functionality is not independent of each "
          "other. Their functioning is determined by some sort of load "
          "balancing algrothim (implemented in hardware and/or "
          "software). 'Sparing' is implied (i.e. each member can be a "
          "spare for the other(s). \n"
          "- Sparing (=4) indicates that all members are active and "
          "are aware of each others. However, their functionality is "
          "independent until failover. Each member can be a spare for "
          "the other(s). \n"
          "- Limited Sparing (=5) indicates that all members are "
          "active, and they may or may not be aware of each and they "
          "are not spares for each other. Instead, their redundancy is "
          "indicated by the IsSpare relationship."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "..", "0x8000.." }, 
       Values { "Unknown", "Other", "N+1", "Load Balanced", "Sparing",
          "Limited Sparing", "DMTF Reserved", "Vendor Reserved" },
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RedundancySet.OtherTypeOfSet" }]
   uint16 TypeOfSet[];

      [Description (
          "MinNumberNeeded indicates the smallest number of elements "
          "that MUST be operational in order to function. For example, "
          "in an N+1 redundancy relationship, the MinNumberNeeded "
          "property is set equal to N. In a 'LimitedSparing' "
          "environment, this property is meaningless and SHOULD be set "
          "to zero."), 
       MinValue ( 0 )]
   uint32 MinNumberNeeded;

      [Description (
          "MaxNumberSupported indicates the largest number of elements "
          "that can participate in the RedundancySet. A value of 0 "
          "indicates there is no limit on the number of elements.")]
   uint32 MaxNumberSupported;

      [Description (
          "This method forces a failover from one ManagedElement to "
          "another. There are two parameters to the Failover method. \n"
          "- FailoverFrom is a reference to an 'active' ManagedElement "
          "that will become inactive after the method. This element "
          "SHOULD be part of the RedundancySet via a "
          "MemberOfCollection relationship. \n"
          "- FailoverTo is a reference to the ManagedElement that will "
          "take over for the FailoverFrom element. This element SHOULD "
          "either be a member of the RedundancySet or be associated "
          "with the RedundancySet via an IsSpare relationship. \n"
          "\n"
          "Upon sucessful completion: \n"
          "- the FailoverTo element SHOULD be associated to the "
          "RedundancySet via MemberOfCollection. \n"
          "- the FailFrom element SHOULD either still be associated to "
          "the RedundandySet via MemberOfCollection with a "
          "OperationalStatus or EnableState that indicates it not "
          "active, or it SHOULD be associated to the 'Spared' "
          "collection via the MemberOfCollection association."), 
       ValueMap { "0", "1", "2", "3", "4", "..", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported",
          "Unknown/Unspecified Error", "Busy/In Use", "Paramter Error",
          "DMTF Reserved", "Vendor Reserved" }]
   uint32 Failover( 
         [IN, Description (
             "The primary ManagedSystemElement that will become "
             "inactive after the method.")]
      CIM_ManagedElement REF FailoverFrom, 
         [IN, Description (
             "The ManagedSystemElement that will take over from the "
             "primary MSE.")]
      CIM_ManagedElement REF FailoverTo); 

      [Description (
          "VendorIdentifyingInfo captures the vendor identifying data "
          "for the RedundancySet. One example is the product name for "
          "a cluster.")]
   string VendorIdentifyingInfo;

      [Description (
          "When the corresponding array entry in TypeOfSet[] is "
          "'Other', this entry provides a string describing the type "
          "of set."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_RedundancySet.TypeOfSet" }]
   string OtherTypeOfSet[];

      [Write, Description (
          "The current load balance algorithm. \n"
          "Least Blocks, Least IO, and Address Region are used in "
          "storage device path redundancy drivers to optimize load "
          "balancing by routing requests to a path with the least "
          "queued blocks or IO requests, or based on locality of "
          "reference. \n"
          "'Product Specific' indicates that the algorithm is "
          "optimized for a particular type of product. Information "
          "about that product SHOULD be provided in an associated "
          "CIM_Product instance."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7" }, 
       Values { "Unknown", "Other", "No Load Balancing", "Round Robin",
          "Least Blocks", "Least IO", "Address Region",
          "Product Specific" }, 
       ModelCorrespondence { 
          "CIM_RedundancySet.OtherLoadBalanceAlgorithm" }]
   uint16 LoadBalanceAlgorithm = 2;

      [Write, Description (
          "When LoadBalanceAlgorithm is Other, this property describes "
          "the algorithm."), 
       ModelCorrespondence { "CIM_RedundancySet.LoadBalanceAlgorithm" }]
   string OtherLoadBalanceAlgorithm;
};