// ===================================================================
// Title:  Core Redundancy
// $State: Exp $
// $Date: 2004/08/15 05:55:36 $
// $Source: /cvsroot/wbemservices/open/mof/dmtf/2.9/Core_Redundancy.mof,v $
// $Revision: 1.1 $
// ===================================================================
//#pragma inLine ("Includes/copyright.inc")
// Copyright 1998-2004 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.
// DMTF is a not-for-profit association of industry members dedicated
// to promoting enterprise and systems management and interoperability.
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members,
// provided that correct attribution is given.
// As DMTF specifications may be revised from time to time,
// the particular version and release date should always be noted.
// 
// Implementation of certain elements of this standard or proposed
// standard may be subject to third party patent rights, including
// provisional patent rights (herein "patent rights"). DMTF makes
// no representations to users of the standard as to the existence
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or
// claimants, nor for any incomplete or inaccurate identification or
// disclosure of such rights, owners or claimants. DMTF shall have no
// liability to any party, in any manner or circumstance, under any
// legal theory whatsoever, for failure to recognize, disclose, or
// identify any such third party patent rights, or for such party's
// reliance on the standard or incorporation thereof in its product,
// protocols or testing procedures. DMTF shall have no liability to
// any party implementing such standard, whether such implementation
// is foreseeable or not, nor to any patent owner or claimant, and shall
// have no liability or responsibility for costs or losses incurred if
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the
// standard from any and all claims of infringement by a patent owner
// for such implementations.
// 
// For information about patents held by third-parties which have
// notified the DMTF that, in their opinion, such patent may relate to
// or impact implementations of DMTF standards, visit
// http://www.dmtf.org/about/policies/disclosures.php.
//#pragma inLine
// ===================================================================
// Description: The Core Model defines basic management concepts.
//              This file defines the concepts and classes to support
//              Redundancy.
// 
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined
//              by other working groups, are omitted.
// ==================================================================
// Change Log for v2.9 Preliminary
// CR1291 - Add VendorIdentifyingInfo to RedundancySet
// CR1209 - Introduce RedundancySet model to fix and replace
//          the RedundancyGroup mode
// CR1428 - SNIA review tweaks to RedundancySet
// 
// Change Log for v2.8 Final
// CR1210 - Removal of experimental Qualifiers for core.
// CR1223 - SysDev Omnibus CR - Minor MOF corrections.
// 
// Change Log for v2.8 Preliminary
// CR1019 - CIM Versioning for 2.8 Preliminary
// CR1071 - Add RedundancySet, SparedSet, IsSpare, StorageRedundancySet,
//          and ExtraCapacitySet.
// 
// Change Log for v2.7.1
//       - Remove aggregate qualifier from the PartComponent of
//         RedundancyComponent.
// 
// Change Log for v2.7 Final
// CR940 - Fix Value/ValueMap mismatch in StorageRedundancySet.
//         TypeOfAlgorithm
// CR968 - Keep RedundancySet, SparedSet, IsSpare, StorageRedundancySet,
//         and ExtraCapacitySet experimental for 2.8
// 
// Change Log for v2.7
// CR722 - Update description for StorageRedundancyGroup
// CR752 - Add RedundancySet, SparedSet, IsSpare, StorageRedundancySet,
//         and ExtraCapacitySet
//       - Update the description for RedundancyGroup
// ==================================================================

#pragma locale ("en_US")

// ===================================================================
// RedundancySet
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), 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 "
          "RedundancySet. \n"
          "- Redundant (=2) means that there is no single point of "
          "failure. It is possible that some elements in the set have "
          "failed leaving greater than the minimum required "
          "('MinNumberNeeded' ) to have Redundancy. This 'Partial "
          "Redundancy' can be determined by evaluating the number of "
          "failed members in the set. When calculating this number, "
          "failed members with a Spared relationship SHOULD NOT be "
          "included as each has another member that was added to the "
          "set when it failed. \n"
          "- Redundancy Lost (=3) means that a single point of failure "
          "exists. It is possible that some aspects are redundant."), 
       ValueMap { "0", "1", "2", "3", "..", "0x8000.." }, 
       Values { "Unknown", "Other", "Redundant", "Redundancy Lost",
          "DMTF Reserved", "Vendor Reserved" }, 
       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;
};

// ===================================================================
// StorageRedundancySet
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "A class derived from RedundancySet describing storage-related "
       "redundancy information. StorageRedundancySets are used to "
       "protect user data. They aggregate one or more underlying "
       "StorageExtents, associated via MemberOfCollection, and produce "
       "one or more higher-level Extents. The Extents are related to "
       "each other via a BasedOn association. And, the higher level "
       "Extent is related to the StorageRedundancy Set via the "
       "LogicalIdentity association. \n"
       "Note that StorageRedundancySets may overlap in their "
       "aggregation of members. If this occurs, the overlapping "
       "Extents SHOULD NOT contain any check data.")]
class CIM_StorageRedundancySet : CIM_RedundancySet {

      [Description (
          "TypeOfAlgorithm specifies the algorithm used for storage "
          "data redundancy and reconstruction. For example, 'P+Q' (=5) "
          "or 'P+S' (=7) may be specified."), 
       ValueMap { "0", "1", "3", "4", "5", "6", "7" }, 
       Values { "Unknown", "Other", "Copy", "XOR", "P+Q", "S", "P+S" }, 
       MappingStrings { "MIF.DMTF|Redundancy Group|001.2" }, 
       ModelCorrespondence { "CIM_StorageRedundancySet.OtherAlgorithm" 
          }]
   uint16 TypeOfAlgorithm;

      [Description (
          "A string describing the redundancy algorithm when the "
          "TypeOfAlgorithm is set to 1 'Other'."), 
       ModelCorrespondence { "CIM_StorageRedundancySet.TypeOfAlgorithm" 
          }]
   string OtherAlgorithm;
};

// ===================================================================
// IsSpare
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "The IsSpare association indicates an element that can spare or "
       "replace any of the elements in the referenced RedundancySet. "
       "If the 'spare' is itself a Collection, this indicates that "
       "each of the 'spare' members can replace any of the elements in "
       "the RedundancySet. In the case of a collection all of the "
       "values in the properties of this association MUST apply to all "
       "members of the Collection. \n"
       "In the case of a collection, all of the values in the "
       "properties of this association (such as FailoverSupported) "
       "MUST apply to all members. If this is not true, then the "
       "Collection SHOULD be broken down into smaller sets (and the "
       "IsSpare association defined for each of these smallar sets), "
       "such that the properties of this association apply to all "
       "collected members.")]
class CIM_IsSpare : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "A ManagedElement or Collection of elements acting as a "
          "spare.")]
   CIM_ManagedElement REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The set of elements that ARE spared.")]
   CIM_RedundancySet REF Dependent;

      [Description (
          "Indicates theat state of the 'spare'. \n"
          "- Hot Standby. The element is available 'immediately' to "
          "become a functioning member of the set. Such an element is "
          "powered on and has been initialized for it's role as a "
          "spare. \n"
          "- Cold Standby. The element is not available to join the "
          "set without action to prepare it."), 
       ValueMap { "0", "2", "3" }, 
       Values { "Unknown", "Hot Standby", "Cold Standby" }, 
       MappingStrings { "MOF.DMTF|CIM_IsSpare.HotStandby|2.7.1000" }]
   uint8 SpareStatus;

      [Description (
          "Indicates whether or not the failover to the spare is a "
          "manual or automatic."), 
       ValueMap { "0", "2", "3", "4" }, 
       Values { "Unknown", "Automatic", "Manual",
          "Both Manual and Automatic" }]
   uint8 FailoverSupported;
};

// ===================================================================
// Spared
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "The Spared association indicates an element that is acting as "
       "a replacement for another element. If the Dependent references "
       "a Collection, this indicates that 'spared' element is a member "
       "of that collection and the actual mapping between the spare "
       "and the spared is un-important.")]
class CIM_Spared : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "A ManagedElement that has replaced/spared another the "
          "reference Dependent element.")]
   CIM_ManagedElement REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Element or Elements (in the case of a collection) that "
          "have been replaced/spared.")]
   CIM_ManagedElement REF Dependent;
};

// ===================================================================
// RedundancyGroup
// ===================================================================
   [Deprecated { "CIM_RedundancySet" }, Version ( "2.8.1000" ), 
    Description (
       "A class derived from LogicalElement that is a special "
       "collection of ManagedSystemElements. This collection indicates "
       "that the aggregated components together provide redundancy. "
       "All elements aggregated in a RedundancyGroup should be "
       "instantiations of the same object class. \n"
       "The use of this class is being deprecated in lieu of using the "
       "RedundancySet class.")]
class CIM_RedundancyGroup : CIM_LogicalElement {

      [Deprecated { "No Value" }, Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Deprecated { "CIM_RedundancySet.InstanceID" }, Key,
          Override ( "Name" ), Description (
          "The RedundancyGroup Name serves as the key for the Group's "
          "instance in an enterprise environment."), 
       MaxLen ( 256 )]
   string Name;

      [Deprecated { "CIM_RedundancySet.RedundancyStatus" }, 
       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 failures have "
          "been experienced but some reduced amount of redundancy is "
          "still available; \"Redundancy Lost\" (4) means that a "
          "sufficient number of failures have been experienced such "
          "that no redundancy is available and the next failure "
          "experienced will cause overall failure. Also, the values, "
          "\"Other\" (1) and \"Unknown\" (0), are defined."), 
       ValueMap { "0", "1", "2", "3", "4" }, 
       Values { "Unknown", "Other", "Fully Redundant",
          "Degraded Redundancy", "Redundancy Lost" }]
   uint16 RedundancyStatus;
};


// ===================================================================
// RedundancyComponent
// ===================================================================
   [Association, Deprecated { "CIM_MemberOfCollection" }, Aggregation,
    Version ( "2.8.1000" ), Description (
       "A RedundancyGroup aggregates Managed System Elements and "
       "indicates that these elements, taken together, provide "
       "redundancy. All elements aggregated in a RedundancyGroup "
       "should be instantiations of the same object class. \n"
       "The use of this class is being depreacted in lieu of using "
       "MemberOfCollection in conjunction with RedundancySet.")]
class CIM_RedundancyComponent : CIM_Component {

      [Deprecated { "CIM_MemberOfCollection.Collection" }, Aggregate,
       Override ( "GroupComponent" ), Description (
          "The RedundancyComponent association indicates that 'this "
          "set of fans' or 'these physical extents' participate in a "
          "single RedundancyGroup.")]
   CIM_RedundancyGroup REF GroupComponent;

      [Deprecated { "CIM_MemberOfCollection.Member" },
          Override ( "PartComponent" ), Description (
          "The component of the redundancy group.")]
   CIM_ManagedSystemElement REF PartComponent;
};


// ===================================================================
// SpareGroup
// ===================================================================
   [Deprecated { "CIM_RedundancySet" }, Version ( "2.8.1000" ), 
    Description (
       "A class derived from RedundancyGroup indicating that one or "
       "more of the aggregated elements can be spared. (The actual "
       "Spares are defined using the ActsAsSpare association.) An "
       "example is the use of redundant NICs in a ComputerSystem - "
       "where one NIC is primary and the other is Spare. The 'primary' "
       "NIC would be a member of the SpareGroup (associated using the "
       "RedundancyComponent class) and the 'other' NIC would be "
       "associated using the ActsAsSpare relationship. \n"
       "The use of the class is being deprecated in lieu of using the "
       "RedundancySet class.")]
class CIM_SpareGroup : CIM_RedundancyGroup {

      [Deprecated { "CIM_RedundancySet.FailOver()" }, Description (
          "This method is forces a failover from one ManagedSystem "
          "Element to another. There are two parameters to the "
          "Failover method, FailoverFrom and FailoverTo. The "
          "FailoverFrom parameter is a reference to the primary "
          "ManagedSystemElement that will become inactive after the "
          "method. This Element should be associated with the "
          "SpareGroup through the RedundancyComponent relationship. "
          "The FailoverTo parameter is a reference to the "
          "ManagedSystemElement that will take over for the primary. "
          "This Element should be associated with the SpareGroup "
          "through the ActsAsSpare association. Once the failover has "
          "occurred, the SpareGroup and the Redundancy Component and "
          "ActsAsSpare associations will be updated with current "
          "status. For example, the ActsAsSpare association that "
          "contained the FailoverTo Element will be deleted and a new "
          "RedundancyComponent association instantiated in its place. "
          "The method should return 0 if successful, 1 if the request "
          "is not supported, and some other value if any other error "
          "occurred. In a subclass, the set of possible return codes "
          "could be specified, using a ValueMap qualifier on the "
          "method. The strings to which the ValueMap contents are "
          "'translated' may also be specified in the subclass as a "
          "Values array qualifier.")]
   uint32 Failover( 
         [IN, Description (
             "The primary ManagedSystemElement that will become "
             "inactive after the method.")]
      CIM_ManagedSystemElement REF FailoverFrom, 
         [IN, Description (
             "The ManagedSystemElement that will take over from the "
             "primary MSE.")]
      CIM_ManagedSystemElement REF FailoverTo); 
};


// ===================================================================
// ActsAsSpare
// ===================================================================
   [Association, Deprecated { "CIM_IsSpare" }, Version ( "2.8.1000" ), 
    Description (
       "The ActsAsSpare association indicates which elements can spare "
       "or replace the other aggregated elements. The fact that a "
       "spare can operate in \"hot standby\" mode is specified on an "
       "element by element basis. \n"
       "The use of this class is being deprecated in lieu of using the "
       "IsSpare relationship.")]
class CIM_ActsAsSpare {

      [Deprecated { "CIM_IsSpare.Dependent" }, Key, Description (
          "The SpareGroup.")]
   CIM_SpareGroup REF Group;

      [Deprecated { "CIM_IsSpare.Antecedent" }, Key, Description (
          "A ManagedSystemElement acting as a spare and participating "
          "in the SpareGroup.")]
   CIM_ManagedSystemElement REF Spare;

      [Deprecated { "CIM_IsSpare.SpareStatus" }, Description (
          "HotStandby is a boolean indicating that the spare is "
          "operating as a hot standby.")]
   boolean HotStandby;
};


// ===================================================================
// StorageRedundancyGroup
// ===================================================================
   [Deprecated { "CIM_StorageRedundancySet" }, Version ( "2.8.1000" ), 
    Description (
       "A class derived from RedundancyGroup containing mass "
       "storage-related redundancy information. StorageRedundancy "
       "Groups are used to protect user data. They act on one or more "
       "underlying StorageExtents, associated via "
       "ExtentRedundancyComponent and produce one or more protected "
       "StorageExtents that are associated to the underlying "
       "StorageExtents via ProtectedExtentBasedOn or "
       "CompositeExtentBasedOn. StorageRedundancyGroups may overlap. "
       "However, the underlying StorageExtents within the overlap "
       "should not contain any check data. \n"
       "The use of this class is being deprecated in lieu of using the "
       "StorageRedundancySet class.")]
class CIM_StorageRedundancyGroup : CIM_RedundancyGroup {

      [Deprecated { "CIM_StorageRedundancySet.TypeOfAlgorithm" }, 
       Description (
          "The TypeOfAlgorithm specifies the algorithm used for data "
          "redundancy and reconstruction. For example, \"P+Q\" (value "
          "=5) or \"P+S\" (7) may be specified. The value of 0, is "
          "defined as \"None\" to indicate that data redundancy is not "
          "active. An inactive redundancy should only be instantiated "
          "if data striping or concatenation are active. These are "
          "indicated by the IsStriped or IsConcatentated boolean "
          "properties of this RedundancyGroup."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7" }, 
       Values { "None", "Other", "Unknown", "Copy", "XOR", "P+Q", "S",
          "P+S" }, 
       MappingStrings { "MIF.DMTF|Redundancy Group|001.2" }]
   uint16 TypeOfAlgorithm;

      [Deprecated { "No Value" }, Description (
          "StorageRedundancy provides additional information on the "
          "state of the RedundancyGroup, beyond the RedundancyStatus "
          "property. Information like \"Reconfig In Progress\" (value "
          "=1) or \"Redundancy Disabled\" can be specified using this "
          "property."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8" }, 
       Values { "No Additional Status", "Reconfig In Progress",
          "Data Lost", "Not Currently Configured", "Protected Rebuild",
          "Redundancy Disabled", "Unprotected Rebuild",
          "Recalculating", "Verifying" }]
   uint16 StorageRedundancy;

      [Deprecated { "CIM_CompositeExtent.ExtentStripeLength" }, 
       Description (
          "True indicates that the data is striped across the various "
          "StorageExtents in the Group.")]
   boolean IsStriped;

      [Deprecated { "CIM_CompositeExtent.IsConcatenated" }, 
       Description (
          "True indicates that the data is concatenated across the "
          "various StorageExtents in the Group.")]
   boolean IsConcatenated;
};

// ===================================================================
// ExtraCapacityGroup
// ===================================================================
   [Deprecated { "CIM_RedundancySet" }, Version ( "2.8.1000" ), 
    Description (
       "A class derived from RedundancyGroup indicating that the "
       "aggregated elements have more capacity or capability than is "
       "needed. An example of this type of redundancy is the "
       "installation of N+1 power supplies or fans in a system. \n"
       "The use of this class is being deprecated in lieu of using "
       "RedundancySet.")]
class CIM_ExtraCapacityGroup : CIM_RedundancyGroup {

      [Deprecated { "CIM_RedundancySet.MinNumberNeeded" }, 
       Description (
          "MinNumberNeeded indicates the smallest number of elements "
          "that must be operational in order to have redundancy. For "
          "example, in an N+1 redundancy relationship, the "
          "MinNumberNeeded property should be set equal to N.")]
   uint32 MinNumberNeeded;

      [Deprecated { "CIM_RedundancySet.TypeOfSet" }, Description (
          "Boolean indicating whether load balancing is supported by "
          "the ExtraCapacityGroup.")]
   boolean LoadBalancedGroup;
};


// ===================================================================
// ExtentRedundancyComponent
// ===================================================================
   [Association, Deprecated { "CIM_MemberOfCollection" }, Aggregation,
    Version ( "2.8.1000" ), Description (
       "Describes the StorageExtents participating in a Storage "
       "RedundancyGroup. \n"
       "The use of this class is being deprecated in lieu of using "
       "MemberOfCollection in conjunction with StorageRedundancySet.")]
class CIM_ExtentRedundancyComponent : CIM_RedundancyComponent {

      [Deprecated { "CIM_MemberOfCollection.Collection" }, Aggregate,
       Override ( "GroupComponent" ), Description (
          "The StorageRedundancyGroup.")]
   CIM_StorageRedundancyGroup REF GroupComponent;

      [Deprecated { "CIM_MemberOfCollection.Member" },
          Override ( "PartComponent" ), Description (
          "The StorageExtent participating in the RedundancyGroup.")]
   CIM_StorageExtent REF PartComponent;
};


// ===================================================================
// end of file
// ===================================================================
