// =================================================================== // Title: Core Redundancy // $State: dead $ // $Date: 2005/02/24 20:47:32 $ // $Source: /cvs/MSB/pegasus/Schemas/CIMPrelim29/Attic/Core_Redundancy.mof,v $ // $Revision: 1.2 $ // =================================================================== //#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 // ===================================================================