cim_policyrule.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="ArchCR00066.004" type="add">Add UmlPackagePath
// qualifier values to CIM Schema.</change>
// ==================================================================
//  CIM_PolicyRule
// ==================================================================
   [UMLPackagePath ( "CIM::Policy" ), Version ( "2.7.0" ), 
    Description (
       "The central class used for representing the 'If Condition then "
       "Action' semantics of a policy rule. A PolicyRule condition, in "
       "the most general sense, is represented as either an ORed set "
       "of ANDed conditions (Disjunctive Normal Form, or DNF) or an "
       "ANDed set of ORed conditions (Conjunctive Normal Form, or "
       "CNF). Individual conditions may either be negated (NOT C) or "
       "unnegated (C). The actions specified by a PolicyRule are to be "
       "performed if and only if the PolicyRule condition (whether it "
       "is represented in DNF or CNF) evaluates to TRUE. \n"
       "\n"
       "The conditions and actions associated with a PolicyRule are "
       "modeled, respectively, with subclasses of PolicyCondition and "
       "PolicyAction. These condition and action objects are tied to "
       "instances of PolicyRule by the PolicyConditionInPolicyRule and "
       "PolicyActionInPolicyRule aggregations. \n"
       "\n"
       "A PolicyRule may also be associated with one or more policy "
       "time periods, indicating the schedule according to which the "
       "policy rule is active and inactive. In this case it is the "
       "PolicySetValidityPeriod aggregation that provides this "
       "linkage. \n"
       "\n"
       "The PolicyRule class uses the property ConditionListType, to "
       "indicate whether the conditions for the rule are in DNF "
       "(disjunctive normal form), CNF (conjunctive normal form) or, "
       "in the case of a rule with no conditions, as an "
       "UnconditionalRule. The PolicyConditionInPolicyRule aggregation "
       "contains two additional properties to complete the "
       "representation of the Rule's conditional expression. The first "
       "of these properties is an integer to partition the referenced "
       "PolicyConditions into one or more groups, and the second is a "
       "Boolean to indicate whether a referenced Condition is negated. "
       "An example shows how ConditionListType and these two "
       "additional properties provide a unique representation of a set "
       "of PolicyConditions in either DNF or CNF. \n"
       "\n"
       "Suppose we have a PolicyRule that aggregates five "
       "PolicyConditions C1 through C5, with the following values in "
       "the properties of the five PolicyConditionInPolicyRule "
       "associations: \n"
       "C1: GroupNumber = 1, ConditionNegated = FALSE \n"
       "C2: GroupNumber = 1, ConditionNegated = TRUE \n"
       "C3: GroupNumber = 1, ConditionNegated = FALSE \n"
       "C4: GroupNumber = 2, ConditionNegated = FALSE \n"
       "C5: GroupNumber = 2, ConditionNegated = FALSE \n"
       "\n"
       "If ConditionListType = DNF, then the overall condition for the "
       "PolicyRule is: \n"
       "(C1 AND (NOT C2) AND C3) OR (C4 AND C5) \n"
       "\n"
       "On the other hand, if ConditionListType = CNF, then the "
       "overall condition for the PolicyRule is: \n"
       "(C1 OR (NOT C2) OR C3) AND (C4 OR C5) \n"
       "\n"
       "In both cases, there is an unambiguous specification of the "
       "overall condition that is tested to determine whether to "
       "perform the PolicyActions associated with the PolicyRule. \n"
       "\n"
       "PolicyRule instances may also be used to aggregate other "
       "PolicyRules and/or PolicyGroups. When used in this way to "
       "implement nested rules, the conditions of the aggregating rule "
       "apply to the subordinate rules as well. However, any side "
       "effects of condition evaluation or the execution of actions "
       "MUST NOT affect the result of the evaluation of other "
       "conditions evaluated by the rule engine in the same evaluation "
       "pass. That is, an implementation of a rule engine MAY evaluate "
       "all conditions in any order before applying the priority and "
       "determining which actions are to be executed.")]
class CIM_PolicyRule : CIM_PolicySet {

      [Key, Propagated ( "CIM_System.CreationClassName" ), 
       Description (
          "The scoping System's CreationClassName."), 
       MaxLen ( 256 )]
   string SystemCreationClassName;

      [Key, Propagated ( "CIM_System.Name" ), Description (
          "The scoping System's Name."), 
       MaxLen ( 256 )]
   string SystemName;

      [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;

      [Key, Description (
          "A user-friendly name of this PolicyRule."), 
       MaxLen ( 256 )]
   string PolicyRuleName;

      [Description (
          "Indicates whether the list of PolicyConditions associated "
          "with this PolicyRule is in disjunctive normal form (DNF), "
          "conjunctive normal form (CNF), or has no conditions (i.e., "
          "is an UnconditionalRule) and is automatically evaluated to "
          "\"True.\" The default value is 1 (\"DNF\")."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unconditional Rule", "DNF", "CNF" }]
   uint16 ConditionListType = 1;

      [Description (
          "A free-form string that can be used to provide guidelines "
          "on how this PolicyRule should be used.")]
   string RuleUsage;

      [Deprecated { "CIM_PolicySetComponent.Priority" }, Description (
          "PolicyRule.Priority is deprecated and replaced by providing "
          "the priority for a rule (and a group) in the context of the "
          "aggregating PolicySet instead of the priority being used "
          "for all aggregating PolicySet instances. Thus, the "
          "assignment of priority values is much simpler. \n"
          "\n"
          "A non-negative integer for prioritizing this Policy Rule "
          "relative to other Rules. A larger value indicates a higher "
          "priority. The default value is 0.")]
   uint16 Priority = 0;

      [Deprecated { "No Value" }, Description (
          "A flag indicating that the evaluation of the Policy "
          "Conditions and execution of PolicyActions (if the "
          "Conditions evaluate to TRUE) is required. The evaluation of "
          "a PolicyRule MUST be attempted if the Mandatory property "
          "value is TRUE. If the Mandatory property is FALSE, then the "
          "evaluation of the Rule is 'best effort' and MAY be ignored.")]
   boolean Mandatory;

      [Description (
          "This property gives a policy administrator a way of "
          "specifying how the ordering of the PolicyActions associated "
          "with this PolicyRule is to be interpreted. Three values are "
          "supported: \n"
          "o mandatory(1): Do the actions in the indicated order, or "
          "don't do them at all. \n"
          "o recommended(2): Do the actions in the indicated order if "
          "you can, but if you can't do them in this order, do them in "
          "another order if you can. \n"
          "o dontCare(3): Do them -- I don't care about the order. \n"
          "The default value is 3 (\"DontCare\")."), 
       ValueMap { "1", "2", "3" }, 
       Values { "Mandatory", "Recommended", "Dont Care" }]
   uint16 SequencedActions = 3;

      [Description (
          "ExecutionStrategy defines the strategy to be used in "
          "executing the sequenced actions aggregated by this "
          "PolicyRule. There are three execution strategies: \n"
          "\n"
          "Do Until Success - execute actions according to predefined "
          "order, until successful execution of a single action. \n"
          "Do All - execute ALL actions which are part of the modeled "
          "set, according to their predefined order. Continue doing "
          "this, even if one or more of the actions fails. \n"
          "Do Until Failure - execute actions according to predefined "
          "order, until the first failure in execution of an action "
          "instance."), 
       ValueMap { "1", "2", "3" }, 
       Values { "Do Until Success", "Do All", "Do Until Failure" }]
   uint16 ExecutionStrategy;
};