version 1.1, 2001/08/07 11:08:22
|
version 1.1.2.1, 2001/08/07 11:08:22
|
|
|
|
// ================================================================== |
|
// Title: Core Policy MOF Specification 2.6 |
|
// Filename: CIM_Policy26.MOF |
|
// Version: 2.6 |
|
// Release: 0 |
|
// Date: 07/24/2001 |
|
// =================================================================== |
|
// Copyright "2001" 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 cited should always be noted. |
|
// |
|
// Last updated by: Bob Moore |
|
// |
|
// Description: The object classes below are listed in an order that |
|
// avoids forward references. Required objects, defined |
|
// by other working groups, are omitted. |
|
// |
|
// The Policy Model provides a framework for specifying |
|
// configuration information in a scalable way using |
|
// rules composed for conditions and actions. |
|
// |
|
// CIMCR614 - Add CompoundPolicyAction for CIM 2.6 |
|
// - Add CompoundPolicyAction as a subclass of PolicyAction |
|
// - Add PolicyActionStructure abstract aggregation as a |
|
// subclass of PolicyComponent |
|
// - Change derivation of PolicyActionInPolicyRule from |
|
// PolicyComponent to PolicyActionStructure and, thus, |
|
// move ActionOrder property up to parent class |
|
// - Add PolicyActionInPolicyAction aggregation as a |
|
// subclass of PolicyActionStructure |
|
// |
|
// CIMCR597a - PCIMe updates for 2.6 |
|
// - Edit Policy description |
|
// - Add PolicySet & derive PolicyGroup & PolicyRule |
|
// - Deprecate PolicyRule.Priority for |
|
// PolicySetComponent.Priority |
|
// - Remove PolicyRule.PolicyRoles (it's in PolicySet) |
|
// - Add PolicyRule.ExecutionStrategy |
|
// - Deprecate PolicyRepository & replace with |
|
// ReusablePolicyContainer |
|
// - Add PolicySetInSystem |
|
// - Add PolicySetComponent & deprecate ...InPolicyGroup |
|
// & derive PolicyGroupInSystem & PolicyRuleInSystem |
|
// - Add ContainedDomain (to Core) |
|
// & deprecate PolicyRepositoryInPolicyRepository |
|
// - Add ReusablePolicy & deprecate ...InPolicyRepository |
|
// CIMCR516a - Rooted the model associations under Policy |
|
// Component or PolicyInSystem. Corrected PolicyCondition/ |
|
// PolicyActionInPolicyRepository to subclass from |
|
// PolicyInSystem (similar to Groups and Roles 'InSystem') |
|
// |
|
// ================================================================== |
|
// Author: DMTF SLA (Service Level Agreement) Working Group |
|
// ================================================================== |
|
// Pragmas |
|
// ================================================================== |
|
#pragma Locale ("en-US") |
|
|
|
// ================================================================== |
|
// Policy |
|
// ================================================================== |
|
[Abstract, Description ( |
|
"An abstract class defining the common properties of the policy " |
|
"managed elements derived from CIM_Policy. The subclasses are " |
|
"used to create rules and groups of rules that work together to " |
|
"form a coherent set of policies within an administrative domain " |
|
"or set of domains.") |
|
] |
|
class CIM_Policy : CIM_ManagedElement |
|
{ |
|
[Description ( |
|
"A user-friendly name of this policy-related object.") |
|
] |
|
string CommonName; |
|
[Description ( |
|
"An array of keywords for characterizing / categorizing " |
|
"policy objects. Keywords are of one of two types: \n" |
|
"- Keywords defined in this and other MOFs, or in DMTF" |
|
"white papers. These keywords provide a vendor-" |
|
"independent, installation-independent way of " |
|
"characterizing policy objects. \n" |
|
"- Installation-dependent keywords for characterizing " |
|
"policy objects. Examples include 'Engineering', " |
|
"'Billing', and 'Review in December 2000'. \n" |
|
"This MOF defines the following keywords: 'UNKNOWN', " |
|
"'CONFIGURATION', 'USAGE', 'SECURITY', 'SERVICE', " |
|
"'MOTIVATIONAL', 'INSTALLATION', and 'EVENT'. These " |
|
"concepts are self-explanatory and are further discussed " |
|
"in the SLA/Policy White Paper. One additional keyword " |
|
"is defined: 'POLICY'. The role of this keyword is to " |
|
"identify policy-related instances that may not be otherwise " |
|
"identifiable, in some implementations. The keyword 'POLICY' " |
|
"is NOT mutually exclusive of the other keywords " |
|
"specified above.") |
|
] |
|
string PolicyKeywords []; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicySet |
|
// ================================================================== |
|
[Abstract, Description ("PolicySet is an abstract class that " |
|
"represents a set of policies that form a coherent set. The " |
|
"set of contained policies has a common decision strategy and " |
|
"a common set of policy roles. Subclasses include " |
|
"PolicyGroup and PolicyRule.")] |
|
class CIM_PolicySet : CIM_Policy |
|
{ |
|
[Description ("PolicyDecisionStrategy defines the evaluation " |
|
"method used for policies contained in the PolicySet. " |
|
"FirstMatching enforces the actions of the first rule that " |
|
"evaluates to TRUE. It is the only value currently defined."), |
|
ValueMap { "1" }, |
|
Values { "FirstMatching" } |
|
] |
|
uint16 PolicyDecisionStrategy; |
|
[Description ( |
|
"The PolicyRoles property represents the roles and role " |
|
"combinations associated with a PolicySet. All contained " |
|
"PolicySet instances inherit the values of the PolicyRoles of " |
|
"the aggregating PolicySet but the values are not copied. " |
|
"A contained PolicySet instance may, however, add additional " |
|
"PolicyRoles to those it inherits from its aggregating " |
|
"PolicySet(s)\n" |
|
"\n" |
|
"Each value represents one role or role combination. Since " |
|
"this is a multi-valued property, more than one role or " |
|
"combination can be associated with a single PolicySet. Each " |
|
"value is a string of the form:\n" |
|
" <RoleName>[&&<RoleName>]*\n" |
|
"where the individual role names appear in alphabetical order " |
|
"(according to the collating sequence for UCS-2).") ] |
|
string PolicyRoles []; |
|
|
|
}; |
|
|
|
|
|
// ================================================================== |
|
// PolicyGroup |
|
// ================================================================== |
|
[Description ( |
|
"An aggregation of PolicySet instances (PolicyGroups and/or " |
|
"PolicyRules) that have the same decision strategy and inherit " |
|
"policy roles. PolicyGroup instances are defined and named " |
|
"relative to the CIM_System that provides their context.") |
|
] |
|
class CIM_PolicyGroup : CIM_PolicySet |
|
{ |
|
[Propagated("CIM_System.CreationClassName"), |
|
Key, MaxLen (256), |
|
Description ("The scoping System's CreationClassName.") |
|
] |
|
string SystemCreationClassName; |
|
[Propagated("CIM_System.Name"), |
|
Key, MaxLen (256), |
|
Description ("The scoping System's Name.") |
|
] |
|
string SystemName; |
|
[Key, MaxLen (256), 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.") ] |
|
string CreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"A user-friendly name of this PolicyGroup.") |
|
] |
|
string PolicyGroupName; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyRule |
|
// ================================================================== |
|
[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 " |
|
"PolicyRuleValidityPeriod 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 or " |
|
"CNF. 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 |
|
{ |
|
[Propagated("CIM_System.CreationClassName"), |
|
Key, MaxLen (256), |
|
Description ("The scoping System's CreationClassName.") |
|
] |
|
string SystemCreationClassName; |
|
[Propagated("CIM_System.Name"), |
|
Key, MaxLen (256), |
|
Description ("The scoping System's Name.") |
|
] |
|
string SystemName; |
|
[Key, MaxLen (256), 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.") ] |
|
string CreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"A user-friendly name of this PolicyRule.") |
|
] |
|
string PolicyRuleName; |
|
[Description ( |
|
"Indicates whether this PolicyRule is administratively " |
|
"enabled, administratively disabled, or enabled for " |
|
"debug. When the property has the value 3 (\"enabledFor" |
|
"Debug\"), the entity evaluating the PolicyConditions is " |
|
"instructed to evaluate the conditions for the Rule, but not " |
|
"to perform the actions if the PolicyConditions evaluate to " |
|
"TRUE. This serves as a debug vehicle when attempting to " |
|
"determine what policies would execute in a particular " |
|
"scenario, without taking any actions to change state " |
|
"during the debugging. The default value is 1 " |
|
"(\"enabled\")."), |
|
ValueMap { "1", "2", "3" }, |
|
Values { "enabled", "disabled", "enabledForDebug" } |
|
] |
|
uint16 Enabled; |
|
[Description ( |
|
"Indicates whether the list of PolicyConditions " |
|
"associated with this PolicyRule is in disjunctive " |
|
"normal form (DNF) or conjunctive normal form (CNF)." |
|
"The default value is 1 (\"DNF\")."), |
|
ValueMap { "1", "2" }, |
|
Values { "DNF", "CNF" } |
|
] |
|
uint16 ConditionListType; |
|
[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; |
|
[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", "dontCare" } |
|
] |
|
uint16 SequencedActions; |
|
[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\n" |
|
" order, until successful execution of a\n" |
|
" single action.\n" |
|
"Do All - execute ALL actions which are part of\n" |
|
" the modeled set, according to their\n" |
|
" predefined order. Continue doing this,\n" |
|
" even if one or more of the actions fails.\n" |
|
"Do Until Failure - execute actions according to predefined\n" |
|
" order, until the first failure in\n" |
|
" execution of an action instance."), |
|
ValueMap {"1", "2", "3"}, |
|
Values {"Do Until Success", "Do All", "Do Until Failure"}] |
|
uint16 ExecutionStrategy; |
|
}; |
|
|
|
// ================================================================== |
|
// ReusablePolicyContainer |
|
// ================================================================== |
|
[Description ( |
|
"A class representing an administratively defined " |
|
"container for reusable policy-related information. " |
|
"This class does not introduce any additional " |
|
"properties beyond those in its superclass " |
|
"AdminDomain. It does, however, participate in a " |
|
"unique association for containing policy elements." |
|
"\n\n" |
|
"An instance of this class uses the NameFormat value" |
|
"\"ReusablePolicyContainer\".") |
|
] |
|
class CIM_ReusablePolicyContainer : CIM_AdminDomain |
|
{ |
|
}; |
|
|
|
|
|
// ================================================================== |
|
// PolicyRepository *** deprecated |
|
// ================================================================== |
|
[DEPRECATED{"CIM_ReusablePolicyContainer"}, |
|
Description ( |
|
"The term 'PolicyRepository' has been confusing to both " |
|
"developers and users of the model. The replacement class " |
|
"name describes model element properly and is less likely " |
|
"to be confused with a data repository." |
|
"\n\n" |
|
"A class representing an administratively defined " |
|
"container for reusable policy-related information. " |
|
"This class does not introduce any additional " |
|
"properties beyond those in its superclass " |
|
"AdminDomain. It does, however, participate in a " |
|
"number of unique associations." |
|
"\n\n" |
|
"An instance of this class uses the NameFormat value" |
|
"\"PolicyRepository\".") |
|
] |
|
class CIM_PolicyRepository : CIM_AdminDomain |
|
{ |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyCondition |
|
// ================================================================== |
|
[Abstract, Description ( |
|
"A class representing a rule-specific or reusable policy " |
|
"condition to be evaluated in conjunction with a Policy" |
|
"Rule. Since all operational details of a PolicyCondition " |
|
"are provided in subclasses of this object, this class is " |
|
"abstract.") |
|
] |
|
class CIM_PolicyCondition : CIM_Policy |
|
{ |
|
[Key, MaxLen (256), Description ( |
|
" The name of the class or the subclass used in the " |
|
"creation of the System object in whose scope this " |
|
"PolicyCondition is defined.\n\n" |
|
" " |
|
"This property helps to identify the System object in " |
|
"whose scope this instance of PolicyCondition exists. " |
|
"For a rule-specific PolicyCondition, this is the System " |
|
"in whose context the PolicyRule is defined. For a " |
|
"reusable PolicyCondition, this is the instance of " |
|
"PolicyRepository (which is a subclass of System) that " |
|
"holds the Condition.\n\n" |
|
" " |
|
"Note that this property, and the analogous property " |
|
"SystemName, do not represent propagated keys from an " |
|
"instance of the class System. Instead, they are " |
|
"properties defined in the context of this class, which " |
|
"repeat the values from the instance of System to which " |
|
"this PolicyCondition is related, either directly via the " |
|
"PolicyConditionInPolicyRepository association or indirectly " |
|
"via the PolicyConditionInPolicyRule aggregation.") |
|
] |
|
string SystemCreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
" The name of the System object in whose scope this " |
|
"PolicyCondition is defined.\n\n" |
|
" " |
|
"This property completes the identification of the System " |
|
"object in whose scope this instance of PolicyCondition " |
|
"exists. For a rule-specific PolicyCondition, this is the " |
|
"System in whose context the PolicyRule is defined. For a " |
|
"reusable PolicyCondition, this is the instance of " |
|
"PolicyRepository (which is a subclass of System) that " |
|
"holds the Condition.") |
|
] |
|
string SystemName; |
|
[Key, MaxLen (256), Description ( |
|
"For a rule-specific PolicyCondition, the " |
|
"CreationClassName of the PolicyRule object with which " |
|
"this Condition is associated. For a reusable Policy" |
|
"Condition, a special value, 'NO RULE', should be used to " |
|
"indicate that this Condition is reusable and not " |
|
"associated with a single PolicyRule.") |
|
] |
|
string PolicyRuleCreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"For a rule-specific PolicyCondition, the name of " |
|
"the PolicyRule object with which this Condition is " |
|
"associated. For a reusable PolicyCondition, a " |
|
"special value, 'NO RULE', should be used to indicate " |
|
"that this Condition is reusable and not associated " |
|
"with a single PolicyRule.") |
|
] |
|
string PolicyRuleName; |
|
[Key, MaxLen (256), 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.") ] |
|
string CreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"A user-friendly name of this PolicyCondition.") |
|
] |
|
string PolicyConditionName; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyTimePeriodCondition |
|
// ================================================================== |
|
[Description ( |
|
" This class provides a means of representing the time " |
|
"periods during which a PolicyRule is valid, i.e., active. " |
|
"At all times that fall outside these time periods, the " |
|
"PolicyRule has no effect. A Rule is treated as valid " |
|
"at ALL times, if it does not specify a " |
|
"PolicyTimePeriodCondition.\n\n" |
|
" " |
|
"In some cases a Policy Consumer may need to perform " |
|
"certain setup / cleanup actions when a PolicyRule becomes " |
|
"active / inactive. For example, sessions that were " |
|
"established while a Rule was active might need to " |
|
"be taken down when the Rule becomes inactive. In other " |
|
"cases, however, such sessions might be left up. In this " |
|
"case, the effect of deactivating the PolicyRule would " |
|
"just be to prevent the establishment of new sessions. \n\n" |
|
" " |
|
"Setup / cleanup behaviors on validity period " |
|
"transitions are not currently addressed by the Policy " |
|
"Model, and must be specified in 'guideline' documents or " |
|
"via subclasses of CIM_PolicyRule, CIM_PolicyTimePeriod" |
|
"Condition or other concrete subclasses of CIM_Policy. If " |
|
"such behaviors need to be under the control of the policy " |
|
"administrator, then a mechanism to allow this control " |
|
"must also be specified in the subclasses.\n\n" |
|
" " |
|
"PolicyTimePeriodCondition is defined as a subclass of " |
|
"PolicyCondition. This is to allow the inclusion of " |
|
"time-based criteria in the AND/OR condition definitions " |
|
"for a PolicyRule.\n\n" |
|
" " |
|
"Instances of this class may have up to five properties " |
|
"identifying time periods at different levels. The values " |
|
"of all the properties present in an instance are ANDed " |
|
"together to determine the validity period(s) for the " |
|
"instance. For example, an instance with an overall " |
|
"validity range of January 1, 2000 through December 31, " |
|
"2000; a month mask that selects March and April; a " |
|
"day-of-the-week mask that selects Fridays; and a time " |
|
"of day range of 0800 through 1600 would be represented " |
|
"using the following time periods:\n" |
|
" Friday, March 5, 2000, from 0800 through 1600;\n " |
|
" Friday, March 12, 2000, from 0800 through 1600;\n " |
|
" Friday, March 19, 2000, from 0800 through 1600;\n " |
|
" Friday, March 26, 2000, from 0800 through 1600;\n " |
|
" Friday, April 2, 2000, from 0800 through 1600;\n " |
|
" Friday, April 9, 2000, from 0800 through 1600;\n " |
|
" Friday, April 16, 2000, from 0800 through 1600;\n " |
|
" Friday, April 23, 2000, from 0800 through 1600;\n " |
|
" Friday, April 30, 2000, from 0800 through 1600.\n\n" |
|
" " |
|
"Properties not present in an instance of " |
|
"PolicyTimePeriodCondition are implicitly treated as having " |
|
"their value 'always enabled'. Thus, in the example above, " |
|
"the day-of-the-month mask is not present, and so the " |
|
"validity period for the instance implicitly includes a " |
|
"day-of-the-month mask that selects all days of the month. " |
|
"If this 'missing property' rule is applied to its fullest, we " |
|
"see that there is a second way to indicate that a Policy" |
|
"Rule is always enabled: associate with it an instance of " |
|
"PolicyTimePeriodCondition whose only properties with " |
|
"specific values are its key properties.") |
|
] |
|
class CIM_PolicyTimePeriodCondition : CIM_PolicyCondition |
|
{ |
|
[Description ( |
|
" This property identifies an overall range of calendar " |
|
"dates and times over which a PolicyRule is valid. It is " |
|
"formatted as a string representing a start date and time, " |
|
"in which the character 'T' indicates the beginning of the " |
|
"time portion, followed by the solidus character '/', " |
|
"followed by a similar string representing an end date and " |
|
"time. The first date indicates the beginning of the range, " |
|
"while the second date indicates the end. Thus, the second " |
|
"date and time must be later than the first. Date/times are " |
|
"expressed as substrings of the form yyyymmddThhmmss. For " |
|
"example: \n" |
|
" 20000101T080000/20000131T120000 defines \n" |
|
" January 1, 2000, 0800 through January 31, 2000, noon\n\n" |
|
" " |
|
"There are also two special cases in which one of the " |
|
"date/time strings is replaced with a special string defined " |
|
"in RFC 2445.\n " |
|
" o If the first date/time is replaced with the string " |
|
" 'THISANDPRIOR', then the property indicates that a " |
|
" PolicyRule is valid [from now] until the date/time " |
|
" that appears after the '/'.\n" |
|
" o If the second date/time is replaced with the string " |
|
" 'THISANDFUTURE', then the property indicates that a " |
|
" PolicyRule becomes valid on the date/time that " |
|
" appears before the '/', and remains valid from that " |
|
" point on. "), |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.MonthOfYearMask", |
|
"CIM_PolicyTimePeriodCondition.DayOfMonthMask", |
|
"CIM_PolicyTimePeriodCondition.DayOfWeekMask", |
|
"CIM_PolicyTimePeriodCondition.TimeOfDayMask", |
|
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} |
|
] |
|
string TimePeriod; |
|
[Octetstring, Description ( |
|
" The purpose of this property is to refine the valid time " |
|
"period that is defined by the TimePeriod property, by " |
|
"explicitly specifying in which months the PolicyRule is " |
|
"valid. These properties work together, with the " |
|
"TimePeriod used to specify the overall time period in " |
|
"which the PolicyRule is valid, and the MonthOfYearMask used " |
|
"to pick out the months during which the Rule is valid.\n\n" |
|
" " |
|
"This property is formatted as an octet string, structured " |
|
"as follows:\n" |
|
" o a 4-octet length field, indicating the length of the " |
|
" entire octet string; this field is always set to " |
|
" 0x00000006 for this property;\n" |
|
" o a 2-octet field consisting of 12 bits identifying the " |
|
" 12 months of the year, beginning with January and " |
|
" ending with December, followed by 4 bits that are " |
|
" always set to '0'. For each month, the value '1' " |
|
" indicates that the policy is valid for that month, " |
|
" and the value '0' indicates that it is not valid.\n\n" |
|
" " |
|
"The value 0x000000060830, for example, indicates that a " |
|
"PolicyRule is valid only in the months May, November, " |
|
"and December.\n\n" |
|
" " |
|
"If a value for this property is not provided, then the " |
|
"PolicyRule is treated as valid for all twelve months, and " |
|
"only restricted by its TimePeriod property value and the " |
|
"other Mask properties."), |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.TimePeriod", |
|
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} |
|
] |
|
uint8 MonthOfYearMask[]; |
|
[Octetstring, Description ( |
|
" The purpose of this property is to refine the valid time " |
|
"period that is defined by the TimePeriod property, by " |
|
"explicitly specifying in which days of the month the Policy" |
|
"Rule is valid. These properties work together, " |
|
"with the TimePeriod used to specify the overall time period " |
|
"in which the PolicyRule is valid, and the DayOfMonthMask used " |
|
"to pick out the days of the month during which the Rule " |
|
"is valid.\n\n " |
|
" " |
|
"This property is formatted as an octet string, structured " |
|
"as follows:\n" |
|
" o a 4-octet length field, indicating the length of the " |
|
" entire octet string; this field is always set to " |
|
" 0x0000000C for this property; \n" |
|
" o an 8-octet field consisting of 31 bits identifying " |
|
" the days of the month counting from the beginning, " |
|
" followed by 31 more bits identifying the days of the " |
|
" month counting from the end, followed by 2 bits that " |
|
" are always set to '0'. For each day, the value '1' " |
|
" indicates that the policy is valid for that day, and " |
|
" the value '0' indicates that it is not valid. \n\n" |
|
" " |
|
"The value 0x0000000C8000000100000000, for example, " |
|
"indicates that a PolicyRule is valid on the first and " |
|
"last days of the month.\n\n " |
|
" " |
|
"For months with fewer than 31 days, the digits corresponding " |
|
"to days that the months do not have (counting in both " |
|
"directions) are ignored.\n\n" |
|
" " |
|
"If a value for this property is not provided, then the " |
|
"PolicyRule is treated as valid for all days of the month, and " |
|
"only restricted by its TimePeriod property value and the " |
|
"other Mask properties."), |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.TimePeriod", |
|
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} |
|
] |
|
uint8 DayOfMonthMask[]; |
|
[Octetstring, Description ( |
|
" The purpose of this property is to refine the valid time " |
|
"period that is defined by the TimePeriod property, by " |
|
"explicitly specifying in which days of the month the Policy" |
|
"Rule is valid. These properties work together, " |
|
"with the TimePeriod used to specify the overall time period " |
|
"in which the PolicyRule is valid, and the DayOfWeekMask used " |
|
"to pick out the days of the week during which the Rule " |
|
"is valid.\n\n " |
|
" " |
|
"This property is formatted as an octet string, structured " |
|
"as follows:\n " |
|
" o a 4-octet length field, indicating the length of the " |
|
" entire octet string; this field is always set to " |
|
" 0x00000005 for this property;\n" |
|
" o a 1-octet field consisting of 7 bits identifying the 7 " |
|
" days of the week, beginning with Sunday and ending with " |
|
" Saturday, followed by 1 bit that is always set to '0'. " |
|
" For each day of the week, the value '1' indicates that " |
|
" the policy is valid for that day, and the value '0' " |
|
" indicates that it is not valid. \n\n" |
|
" " |
|
"The value 0x000000057C, for example, indicates that a " |
|
"PolicyRule is valid Monday through Friday.\n\n" |
|
" " |
|
"If a value for this property is not provided, then the " |
|
"PolicyRule is treated as valid for all days of the week, " |
|
"and only restricted by its TimePeriod property value and " |
|
"the other Mask properties."), |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.TimePeriod", |
|
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} |
|
] |
|
uint8 DayOfWeekMask[]; |
|
[Description ( |
|
" The purpose of this property is to refine the valid time " |
|
"period that is defined by the TimePeriod property, by " |
|
"explicitly specifying a range of times in a day during which " |
|
"the PolicyRule is valid. These properties work " |
|
"together, with the TimePeriod used to specify the overall " |
|
"time period in which the PolicyRule is valid, and the " |
|
"TimeOfDayMask used to pick out the range of time periods " |
|
"in a given day of during which the Rule is valid. \n\n" |
|
" " |
|
"This property is formatted in the style of RFC 2445: a " |
|
"time string beginning with the character 'T', followed by " |
|
"the solidus character '/', followed by a second time string. " |
|
"The first time indicates the beginning of the range, while " |
|
"the second time indicates the end. Times are expressed as " |
|
"substrings of the form 'Thhmmss'. \n\n" |
|
" " |
|
"The second substring always identifies a later time than " |
|
"the first substring. To allow for ranges that span " |
|
"midnight, however, the value of the second string may be " |
|
"smaller than the value of the first substring. Thus, " |
|
"'T080000/T210000' identifies the range from 0800 until 2100, " |
|
"while 'T210000/T080000' identifies the range from 2100 until " |
|
"0800 of the following day. \n\n" |
|
" " |
|
"When a range spans midnight, it by definition includes " |
|
"parts of two successive days. When one of these days is " |
|
"also selected by either the MonthOfYearMask, " |
|
"DayOfMonthMask, and/or DayOfWeekMask, but the other day is " |
|
"not, then the policy is active only during the portion of " |
|
"the range that falls on the selected day. For example, if " |
|
"the range extends from 2100 until 0800, and the day of " |
|
"week mask selects Monday and Tuesday, then the policy is " |
|
"active during the following three intervals:\n" |
|
" From midnight Sunday until 0800 Monday; \n" |
|
" From 2100 Monday until 0800 Tuesday; \n" |
|
" From 2100 Tuesday until 23:59:59 Tuesday. \n\n" |
|
" " |
|
"If a value for this property is not provided, then the " |
|
"PolicyRule is treated as valid for all hours of the day, " |
|
"and only restricted by its TimePeriod property value and " |
|
"the other Mask properties."), |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.TimePeriod", |
|
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} |
|
] |
|
string TimeOfDayMask; |
|
[Description ( |
|
" This property indicates whether the times represented " |
|
"in the TimePeriod property and in the various Mask " |
|
"properties represent local times or UTC times. There is " |
|
"no provision for mixing of local times and UTC times: the " |
|
"value of this property applies to all of the other " |
|
"time-related properties."), |
|
ValueMap { "1", "2" }, |
|
Values { "localTime", "utcTime" }, |
|
ModelCorrespondence { |
|
"CIM_PolicyTimePeriodCondition.TimePeriod", |
|
"CIM_PolicyTimePeriodCondition.MonthOfYearMask", |
|
"CIM_PolicyTimePeriodCondition.DayOfMonthMask", |
|
"CIM_PolicyTimePeriodCondition.DayOfWeekMask", |
|
"CIM_PolicyTimePeriodCondition.TimeOfDayMask"} |
|
] |
|
uint16 LocalOrUtcTime; |
|
}; |
|
|
|
// ================================================================== |
|
// VendorPolicyCondition |
|
// ================================================================== |
|
[Description ( |
|
" A class that provides a general extension mechanism for " |
|
"representing PolicyConditions that have not been modeled " |
|
"with specific properties. Instead, the two properties " |
|
"Constraint and ConstraintEncoding are used to define the " |
|
"content and format of the Condition, as explained below.\n\n" |
|
" " |
|
"As its name suggests, VendorPolicyCondition is intended for " |
|
"vendor-specific extensions to the Policy Core Information " |
|
"Model. Standardized extensions are not expected to use " |
|
"this class.") |
|
] |
|
class CIM_VendorPolicyCondition : CIM_PolicyCondition |
|
{ |
|
[Octetstring, Description ( |
|
"This property provides a general extension mechanism for " |
|
"representing PolicyConditions that have not been " |
|
"modeled with specific properties. The format of the " |
|
"octet strings in the array is left unspecified in " |
|
"this definition. It is determined by the OID value " |
|
"stored in the property ConstraintEncoding. Since " |
|
"ConstraintEncoding is single-valued, all the values of " |
|
"Constraint share the same format and semantics."), |
|
ModelCorrespondence { |
|
"CIM_VendorPolicyCondition.ConstraintEncoding"} |
|
] |
|
string Constraint []; |
|
[Description ( |
|
"An OID encoded as a string, identifying the format " |
|
"and semantics for this instance's Constraint property."), |
|
ModelCorrespondence { |
|
"CIM_VendorPolicyCondition.Constraint"} |
|
] |
|
string ConstraintEncoding; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyAction |
|
// ================================================================== |
|
[Abstract, Description ( |
|
"A class representing a rule-specific or reusable policy " |
|
"action to be performed if the PolicyConditions for a Policy" |
|
"Rule evaluate to TRUE. Since all operational details of a " |
|
"PolicyAction are provided in subclasses of this object, " |
|
"this class is abstract.") |
|
] |
|
class CIM_PolicyAction : CIM_Policy |
|
{ |
|
[Key, MaxLen (256), Description ( |
|
" The name of the class or the subclass used in the " |
|
"creation of the System object in whose scope this " |
|
"PolicyAction is defined. \n\n" |
|
" " |
|
"This property helps to identify the System object in " |
|
"whose scope this instance of PolicyAction exists. " |
|
"For a rule-specific PolicyAction, this is the System " |
|
"in whose context the PolicyRule is defined. For a " |
|
"reusable PolicyAction, this is the instance of " |
|
"PolicyRepository (which is a subclass of System) that " |
|
"holds the Action. \n\n" |
|
" " |
|
"Note that this property, and the analogous property " |
|
"SystemName, do not represent propagated keys from an " |
|
"instance of the class System. Instead, they are " |
|
"properties defined in the context of this class, which " |
|
"repeat the values from the instance of System to which " |
|
"this PolicyAction is related, either directly via the " |
|
"PolicyActionInPolicyRepository association or indirectly " |
|
"via the PolicyActionInPolicyRule aggregation.") |
|
] |
|
string SystemCreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
" The name of the System object in whose scope this " |
|
"PolicyAction is defined. \n\n" |
|
" " |
|
"This property completes the identification of the System " |
|
"object in whose scope this instance of PolicyAction " |
|
"exists. For a rule-specific PolicyAction, this is the " |
|
"System in whose context the PolicyRule is defined. For " |
|
"a reusable PolicyAction, this is the instance of " |
|
"PolicyRepository (which is a subclass of System) that " |
|
"holds the Action.") |
|
] |
|
string SystemName; |
|
[Key, MaxLen (256), Description ( |
|
"For a rule-specific PolicyAction, the CreationClassName " |
|
"of the PolicyRule object with which this Action is " |
|
"associated. For a reusable PolicyAction, a " |
|
"special value, 'NO RULE', should be used to " |
|
"indicate that this Action is reusable and not " |
|
"associated with a single PolicyRule.") |
|
] |
|
string PolicyRuleCreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"For a rule-specific PolicyAction, the name of " |
|
"the PolicyRule object with which this Action is " |
|
"associated. For a reusable PolicyAction, a " |
|
"special value, 'NO RULE', should be used to " |
|
"indicate that this Action is reusable and not " |
|
"associated with a single PolicyRule.") |
|
] |
|
string PolicyRuleName; |
|
[Key, MaxLen (256), 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.") ] |
|
string CreationClassName; |
|
[Key, MaxLen (256), Description ( |
|
"A user-friendly name of this PolicyAction.") |
|
] |
|
string PolicyActionName; |
|
}; |
|
|
|
// ================================================================== |
|
// VendorPolicyAction |
|
// ================================================================== |
|
[Description ( |
|
" A class that provides a general extension mechanism for " |
|
"representing PolicyActions that have not been modeled " |
|
"with specific properties. Instead, the two properties " |
|
"ActionData and ActionEncoding are used to define the " |
|
"content and format of the Action, as explained below.\n\n" |
|
" " |
|
"As its name suggests, VendorPolicyAction is intended for " |
|
"vendor-specific extensions to the Policy Core Information " |
|
"Model. Standardized extensions are not expected to use " |
|
"this class.") ] |
|
class CIM_VendorPolicyAction : CIM_PolicyAction |
|
{ |
|
[Octetstring, Description ( |
|
"This property provides a general extension mechanism for " |
|
"representing PolicyActions that have not been " |
|
"modeled with specific properties. The format of the " |
|
"octet strings in the array is left unspecified in " |
|
"this definition. It is determined by the OID value " |
|
"stored in the property ActionEncoding. Since " |
|
"ActionEncoding is single-valued, all the values of " |
|
"ActionData share the same format and semantics."), |
|
ModelCorrespondence { |
|
"CIM_VendorPolicyAction.ActionEncoding"} |
|
] |
|
string ActionData []; |
|
[Description ( |
|
"An OID encoded as a string, identifying the format " |
|
"and semantics for this instance's ActionData property."), |
|
ModelCorrespondence { |
|
"CIM_VendorPolicyAction.ActionData"} |
|
] |
|
string ActionEncoding; |
|
}; |
|
|
|
// ================================================================== |
|
// CompoundPolicyAction |
|
// ================================================================== |
|
[Description ("CompoundPolicyAction is used to represent an " |
|
"expression consisting of an ordered sequence of action " |
|
"terms. Each action term is represented as a subclass of " |
|
"the PolicyAction class. Compound actions are constructed " |
|
"by associating dependent action terms together using the " |
|
"PolicyActionInPolicyAction aggregation.") ] |
|
class CIM_CompoundPolicyAction : CIM_PolicyAction |
|
{ |
|
[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", "dontCare" }] |
|
uint16 SequencedActions; |
|
|
|
[Description ("ExecutionStrategy defines the strategy to be " |
|
"used in executing the sequenced actions aggregated by this " |
|
"CompoundPolicyAction. There are three execution strategies:" |
|
"\n\n" |
|
"Do Until Success - execute actions according to predefined\n" |
|
" order, until successful execution of a\n" |
|
" single action.\n" |
|
"Do All - execute ALL actions which are part of\n" |
|
" the modeled set, according to their\n" |
|
" predefined order. Continue doing this,\n" |
|
" even if one or more of the actions " |
|
" fails.\n" |
|
"Do Until Failure - execute actions according to predefined\n" |
|
" order, until the first failure in\n" |
|
" execution of an action instance." |
|
"The default value is 2 (\"Do All\")."), |
|
ValueMap {"1", "2", "3"}, |
|
Values {"Do Until Success", "Do All", "Do Until Failure"}] |
|
uint16 ExecutionStrategy; |
|
}; |
|
|
|
// ================================================================== |
|
// === Association classes === |
|
// ================================================================== |
|
|
|
|
|
// ================================================================== |
|
// PolicyComponent |
|
// ================================================================== |
|
[Association, Abstract, Aggregation, Description ( |
|
"CIM_PolicyComponent is a generic association used to " |
|
"establish 'part of' relationships between the subclasses of " |
|
"CIM_Policy. For example, the PolicyConditionInPolicyRule " |
|
"association defines that PolicyConditions are part of a " |
|
"PolicyRule.") |
|
] |
|
class CIM_PolicyComponent |
|
{ |
|
[Aggregate, Key, Description ( |
|
"The parent Policy in the association.") |
|
] |
|
CIM_Policy REF GroupComponent; |
|
[Key, Description ( |
|
"The child/part Policy in the association.") |
|
] |
|
CIM_Policy REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyInSystem |
|
// ================================================================== |
|
[Association, Abstract, Description ( |
|
" CIM_PolicyInSystem is a generic association used to " |
|
"establish dependency relationships between Policies and the " |
|
"Systems that host them. These Systems may be ComputerSystems " |
|
"where Policies are 'running' or they may be Policy" |
|
"Repositories where Policies are stored. This relationship " |
|
"is similar to the concept of CIM_Services being dependent " |
|
"on CIM_Systems as defined by the HostedService " |
|
"association. \n" |
|
" Cardinality is Max(1) for the Antecedent/System " |
|
"reference since Policies can only be hosted in at most one " |
|
"System context. Some subclasses of the association will " |
|
"further refine this definition to make the Policies Weak " |
|
"to Systems. Other subclasses of PolicyInSystem will " |
|
"define an optional hosting relationship. Examples of each " |
|
"of these are the PolicyRuleInSystem and PolicyConditionIn" |
|
"PolicyRepository associations, respectively.") |
|
] |
|
class CIM_PolicyInSystem : CIM_Dependency |
|
{ |
|
[Override ("Antecedent"), Max (1), Description ( |
|
"The hosting System.") |
|
] |
|
CIM_System REF Antecedent; |
|
[Override ("Dependent"), Description ( |
|
"The hosted Policy.") |
|
] |
|
CIM_Policy REF Dependent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicySetInSystem |
|
// ================================================================== |
|
[Association, Abstract, Description ( |
|
"PolicySetInSystem is an abstract association class that " |
|
"represents a relationship between a System and a PolicySet used " |
|
"in the administrative scope of that system (e.g., AdminDomain, " |
|
"ComputerSystem). The Priority property is used to assign a " |
|
"relative priority to a PolicySet within the administrative " |
|
"scope in contexts where it is not a component of another " |
|
"PolicySet.") |
|
] |
|
class CIM_PolicySetInSystem : CIM_PolicyInSystem |
|
{ |
|
[Override ("Antecedent"), Min (1), Max(1), Description ( |
|
"The System in whose scope a PolicySet is defined.") |
|
] |
|
CIM_System REF Antecedent; |
|
[Override ("Dependent"), Description ( |
|
"A PolicySet named within the scope of a System.") |
|
] |
|
CIM_PolicySet REF Dependent; |
|
[Description ( |
|
"The Priority property is used to specify the relative " |
|
"priority of the referenced PolicySet when there are more " |
|
"than one PolicySet instances applied to a managed resource " |
|
"that are not PolicySetComponents and, therefore, have no " |
|
"other relative priority defined. The priority is a " |
|
"non-negative integer; a larger value indicates a higher " |
|
"priority.")] |
|
uint16 Priority; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyGroupInSystem |
|
// ================================================================== |
|
[Association, Description ( |
|
"An association that links a PolicyGroup to the System " |
|
"in whose scope the Group is defined.") |
|
] |
|
class CIM_PolicyGroupInSystem : CIM_PolicySetInSystem |
|
{ |
|
[Override ("Antecedent"), Min(1), Max(1), Description ( |
|
"The System in whose scope a PolicyGroup is defined.") |
|
] |
|
CIM_System REF Antecedent; |
|
[Override ("Dependent"), Weak, Description ( |
|
"A PolicyGroup named within the scope of a System.") |
|
] |
|
CIM_PolicyGroup REF Dependent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyRuleInSystem |
|
// ================================================================== |
|
[Association, Description ( |
|
"An association that links a PolicyRule to the System " |
|
"in whose scope the Rule is defined.") |
|
] |
|
class CIM_PolicyRuleInSystem : CIM_PolicySetInSystem |
|
{ |
|
[Override ("Antecedent"), Min(1), Max(1), Description ( |
|
"The System in whose scope a PolicyRule is defined.") |
|
] |
|
CIM_System REF Antecedent; |
|
[Override ("Dependent"), Weak, Description ( |
|
"A PolicyRule named within the scope of a System.") |
|
] |
|
CIM_PolicyRule REF Dependent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicySetComponent |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
"PolicySetComponent is a concrete aggregation class that " |
|
"collects instances of PolicySet subclasses (PolicyGroups and " |
|
"PolicyRules) into coherent sets of policies that have the same " |
|
"decision strategy and are prioritized within the set.") |
|
] |
|
class CIM_PolicySetComponent : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"A PolicySet that aggregates other PolicySet instances.") |
|
] |
|
CIM_PolicySet REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A PolicySet aggregated into a PolicySet.") |
|
] |
|
CIM_PolicySet REF PartComponent; |
|
[Description ( |
|
"A non-negative integer for prioritizing this PolicySet" |
|
"component relative to components of the same PolicySet. A " |
|
"larger value indicates a higher priority.") |
|
] |
|
uint16 Priority; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyGroupInPolicyGroup *** deprecated |
|
// ================================================================== |
|
[Association, Aggregation, DEPRECATED {"CIM_PolicySetComponent"}, |
|
Description ( |
|
"PolicySetComponent provides a more general mechanism for " |
|
"aggregating both PolicyGroups and PolicyRules and doing so with " |
|
"the priority value applying only to the aggregated set rather " |
|
"than policy wide.\n" |
|
"\n" |
|
"A relationship that aggregates one or more lower-level " |
|
"PolicyGroups into a higher-level Group. A Policy" |
|
"Group may aggregate PolicyRules and/or other Policy" |
|
"Groups.") |
|
] |
|
class CIM_PolicyGroupInPolicyGroup : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"A PolicyGroup that aggregates other Groups.") |
|
] |
|
CIM_PolicyGroup REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A PolicyGroup aggregated by another Group.") |
|
] |
|
CIM_PolicyGroup REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyRuleInPolicyGroup *** deprecated |
|
// ================================================================== |
|
[Association, Aggregation, DEPRECATED {"CIM_PolicySetComponent"}, |
|
Description ( |
|
"PolicySetComponent provides a more general mechanism for " |
|
"aggregating both PolicyGroups and PolicyRules and doing so with " |
|
"the priority value applying only to the aggregated set rather " |
|
"than policy wide.\n" |
|
"\n" |
|
"A relationship that aggregates one or more PolicyRules " |
|
"into a PolicyGroup. A PolicyGroup may aggregate " |
|
"PolicyRules and/or other PolicyGroups.") |
|
] |
|
class CIM_PolicyRuleInPolicyGroup : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"A PolicyGroup that aggregates one or more PolicyRules.") |
|
] |
|
CIM_PolicyGroup REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A PolicyRule aggregated by a PolicyGroup.") |
|
] |
|
CIM_PolicyRule REF PartComponent; |
|
}; |
|
|
|
|
|
// ================================================================== |
|
// PolicyConditionInPolicyRule |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
" A PolicyRule aggregates zero or more instances of the " |
|
"PolicyCondition class, via the PolicyConditionInPolicyRule " |
|
"association. A Rule that aggregates zero Conditions is not " |
|
"valid -- it may, however, be in the process of being entered " |
|
"into a PolicyRepository or being defined for a System. Note " |
|
"that a PolicyRule should have no effect until it is valid.\n\n" |
|
" " |
|
"The Conditions aggregated by a PolicyRule are grouped into " |
|
"two levels of lists: either an ORed set of ANDed sets of " |
|
"conditions (DNF, the default) or an ANDed set of ORed sets " |
|
"of conditions (CNF). Individual PolicyConditions in these " |
|
"lists may be negated. The property ConditionListType " |
|
"specifies which of these two grouping schemes applies to a " |
|
"particular PolicyRule.\n\n" |
|
" " |
|
"In either case, PolicyConditions are used to determine whether " |
|
"to perform the PolicyActions associated with the PolicyRule.\n\n" |
|
" " |
|
"One or more PolicyTimePeriodConditions may be among the " |
|
"conditions associated with a PolicyRule via the Policy" |
|
"ConditionInPolicyRule association. In this case, the time " |
|
"periods are simply additional Conditions to be evaluated " |
|
"along with any others that are specified for the Rule. ") |
|
] |
|
class CIM_PolicyConditionInPolicyRule : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"This property represents the PolicyRule that " |
|
"contains one or more PolicyConditions.") |
|
] |
|
CIM_PolicyRule REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"This property holds the name of a PolicyCondition " |
|
"contained by one or more PolicyRules.") |
|
] |
|
CIM_PolicyCondition REF PartComponent; |
|
[Description ( |
|
"Unsigned integer indicating the group to which the " |
|
"PolicyCondition identified by the ContainedCondition " |
|
"property belongs. This integer segments the Conditions " |
|
"into the ANDed sets (when the ConditionListType is " |
|
"\"DNF\") or similarly the ORed sets (when the Condition" |
|
"ListType is \"CNF\") that are then evaluated.") |
|
] |
|
uint16 GroupNumber; |
|
[Description ( |
|
"Indication of whether the Condition identified by " |
|
"the ContainedCondition property is negated. TRUE " |
|
"indicates that the PolicyCondition IS negated, FALSE " |
|
"indicates that it IS NOT negated.") |
|
] |
|
boolean ConditionNegated; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyRuleValidityPeriod |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
"The PolicyRuleValidityPeriod aggregation represents " |
|
"scheduled activation and deactivation of a PolicyRule. " |
|
"If a PolicyRule is associated with multiple policy time " |
|
"periods via this association, then the Rule is active if " |
|
"at least one of the time periods indicates that it is " |
|
"active. (In other words, the PolicyTimePeriodConditions " |
|
"are ORed to determine whether the Rule is active.) A Time" |
|
"Period may be aggregated by multiple PolicyRules. A Rule " |
|
"that does not point to a PolicyTimePeriodCondition via this " |
|
"association is, from the point of view of scheduling, " |
|
"always active. It may, however, be inactive for other " |
|
"reasons. For example, the Rule's Enabled property may " |
|
"be set to \"disabled\" (value=2).") |
|
] |
|
class CIM_PolicyRuleValidityPeriod : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"This property contains the name of a PolicyRule that " |
|
"contains one or more PolicyTimePeriodConditions.") |
|
] |
|
CIM_PolicyRule REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"This property contains the name of a " |
|
"PolicyTimePeriodCondition defining the valid time periods " |
|
"for one or more PolicyRules.") |
|
] |
|
CIM_PolicyTimePeriodCondition REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyActionStructure |
|
// ================================================================== |
|
[Association, Aggregation, Abstract, Description ( |
|
"PolicyActions may be aggregated into rules and into " |
|
"compound actions. PolicyActionStructure is the abstract " |
|
"aggregation class for the structuring of policy actions.") |
|
] |
|
class CIM_PolicyActionStructure : CIM_PolicyComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"PolicyAction instances may be aggregated into either " |
|
"PolicyRule instances or CompoundPolicyAction instances.")] |
|
CIM_Policy REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A PolicyAction aggregated by a PolicyRule or " |
|
"CompoundPolicyAction.")] |
|
CIM_PolicyAction REF PartComponent; |
|
[Description ( |
|
"ActionOrder is an unsigned integer 'n' that indicates the " |
|
"relative position of a PolicyAction in the sequence of" |
|
"actions associated with a PolicyRule or " |
|
"CompoundPolicyAction. When 'n' is a positive integer, it " |
|
"indicates a place in the sequence of actions to be " |
|
"performed, with smaller integers indicating earlier " |
|
"positions in the sequence. The special value '0' indicates " |
|
"'don't care'. If two or more PolicyActions have the same " |
|
"non-zero sequence number, they may be performed in any " |
|
"order, but they must all be performed at the appropriate " |
|
"place in the overall action sequence.\n" |
|
"\n" |
|
"A series of examples will make ordering of PolicyActions " |
|
"clearer: \n" |
|
" o If all actions have the same sequence number,\n" |
|
" regardless of whether it is '0' or non-zero, any\n" |
|
" order is acceptable.\n" |
|
" o The values: \n" |
|
" 1:ACTION A \n" |
|
" 2:ACTION B \n" |
|
" 1:ACTION C \n" |
|
" 3:ACTION D \n" |
|
" indicate two acceptable orders: A,C,B,D or C,A,B,D,\n" |
|
" since A and C can be performed in either order, but\n" |
|
" only at the '1' position. \n" |
|
" o The values: \n" |
|
" 0:ACTION A \n" |
|
" 2:ACTION B \n" |
|
" 3:ACTION C \n" |
|
" 3:ACTION D \n" |
|
" require that B,C, and D occur either as B,C,D or as\n" |
|
" B,D,C. Action A may appear at any point relative to\n" |
|
" B, C, and D. Thus the complete set of acceptable\n" |
|
" orders is: A,B,C,D; B,A,C,D; B,C,A,D; B,C,D,A; \n" |
|
" A,B,D,C; B,A,D,C; B,D,A,C; B,D,C,A. \n" |
|
"\n" |
|
"Note that the non-zero sequence numbers need not start with " |
|
"'1', and they need not be consecutive. All that matters is " |
|
"their relative magnitude.")] |
|
uint16 ActionOrder; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyActionInPolicyRule |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
" A PolicyRule aggregates zero or more instances of the " |
|
"PolicyAction class, via the PolicyActionInPolicyRule " |
|
"association. A Rule that aggregates zero Actions is not " |
|
"valid--it may, however, be in the process of being entered " |
|
"into a PolicyRepository or being defined for a System. " |
|
"Alternately, the actions of the policy may be explicit in " |
|
"the definition of the PolicyRule. Note that a PolicyRule " |
|
"should have no effect until it is valid.\n\n" |
|
" " |
|
"The Actions associated with a PolicyRule may be given a " |
|
"required order, a recommended order, or no order at all. " |
|
"For Actions represented as separate objects, the " |
|
"PolicyActionInPolicyRule aggregation can be used to express " |
|
"an order." |
|
"\n\n" |
|
"This aggregation does not indicate whether a specified " |
|
"action order is required, recommended, or of no " |
|
"significance; the property SequencedActions in the " |
|
"aggregating instance of PolicyRule provides this " |
|
"indication.")] |
|
class CIM_PolicyActionInPolicyRule : CIM_PolicyActionStructure |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"This property represents the PolicyRule that " |
|
"contains one or more PolicyActions.") |
|
] |
|
CIM_PolicyRule REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"This property holds the name of a PolicyAction " |
|
"contained by one or more PolicyRules.") |
|
] |
|
CIM_PolicyAction REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyActionInPolicyAction |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
"PolicyActionInPolicyAction is used to represent the " |
|
"compounding of policy actions into a higher-level policy " |
|
"action.")] |
|
class CIM_PolicyActionInPolicyAction : CIM_PolicyActionStructure |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"This property represents the CompoundPolicyAction that " |
|
"contains one or more PolicyActions.") |
|
] |
|
CIM_CompoundPolicyAction REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"This property holds the name of a PolicyAction " |
|
"contained by one or more CompoundPolicyActions.") |
|
] |
|
CIM_PolicyAction REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyContainerInPolicyContainer |
|
// ================================================================== |
|
[Association, Aggregation, Description ( |
|
"A relationship that aggregates one or more lower-level " |
|
"ReusablePolicyContainer instances into a higher-level " |
|
"ReusablePolicyContainer.") |
|
] |
|
class CIM_PolicyContainerInPolicyContainer: CIM_SystemComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"A ReusablePolicyContainer that aggregates other " |
|
"ReusablePolicyContainers.") |
|
] |
|
CIM_ReusablePolicyContainer REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A ReusablePolicyContainer aggregated by another " |
|
"ReusablePolicyContainer.") |
|
] |
|
CIM_ReusablePolicyContainer REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyRepositoryInPolicyRepository *** deprecated |
|
// ================================================================== |
|
[Association, Aggregation, |
|
DEPRECATED {"CIM_PolicyContainerInPolicyContainer"}, |
|
Description ( |
|
"The term 'PolicyRepository' has been confusing to both " |
|
"developers and users of the model. The replacement class " |
|
"name describes model element properly and is less likely " |
|
"to be confused with a data repository. ContainedDomain is a " |
|
"general purpose mechanism for expressing domain hierarchy." |
|
"\n\n" |
|
"A relationship that aggregates one or more lower-level " |
|
"PolicyRepositories into a higher-level Repository.") |
|
] |
|
class CIM_PolicyRepositoryInPolicyRepository : CIM_SystemComponent |
|
{ |
|
[Override ("GroupComponent"), Aggregate, Description ( |
|
"A PolicyRepository that aggregates other Repositories.") |
|
] |
|
CIM_PolicyRepository REF GroupComponent; |
|
[Override ("PartComponent"), Description ( |
|
"A PolicyRepository aggregated by another Repository.") |
|
] |
|
CIM_PolicyRepository REF PartComponent; |
|
}; |
|
|
|
// ================================================================== |
|
// ReusablePolicy |
|
// ================================================================== |
|
[Association, Description ( |
|
"The ReusablePolicy association provides for the reuse of any " |
|
"subclass of Policy in a ReusablePolicyContainer.") |
|
] |
|
class CIM_ReusablePolicy : CIM_PolicyInSystem |
|
{ |
|
[Override ("Antecedent"), Max(1), Description ( |
|
"This property identifies a ReusablePolicyContainer that " |
|
"provides the administrative scope for the reuse of the " |
|
"referenced policy element.") |
|
] |
|
CIM_ReusablePolicyContainer REF Antecedent; |
|
[Override ("Dependent"), Description ( |
|
"A reusable policy element.") |
|
] |
|
CIM_Policy REF Dependent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyConditionInPolicyRepository *** deprecated |
|
// ================================================================== |
|
[Association, DEPRECATED {"CIM_ReusablePolicy"}, |
|
Description ( |
|
"The ReusablePolicy association is a more general relationship " |
|
"that incorporates both Conditions and Actions as well as any " |
|
"other policy subclass.\n" |
|
"\n" |
|
"A class representing the hosting of reusable " |
|
"PolicyConditions by a PolicyRepository. A reusable Policy" |
|
"Condition is always related to a single PolicyRepository, " |
|
"via this association.\n\n" |
|
" " |
|
"Note, that an instance of PolicyCondition can be either " |
|
"reusable or rule-specific. When the Condition is rule-" |
|
"specific, it shall not be related to any " |
|
"PolicyRepository via the PolicyConditionInPolicyRepository " |
|
"association.") |
|
] |
|
class CIM_PolicyConditionInPolicyRepository : CIM_PolicyInSystem |
|
{ |
|
[Override ("Antecedent"), Max(1), Description ( |
|
"This property identifies a PolicyRepository " |
|
"hosting one or more PolicyConditions. A reusable " |
|
"PolicyCondition is always related to exactly one " |
|
"PolicyRepository via the PolicyConditionInPolicyRepository " |
|
"association. The [0..1] cardinality for this property " |
|
"covers the two types of PolicyConditions: 0 for a " |
|
"rule-specific PolicyCondition, 1 for a reusable one.") |
|
] |
|
CIM_PolicyRepository REF Antecedent; |
|
[Override ("Dependent"), Description ( |
|
"This property holds the name of a PolicyCondition" |
|
"hosted in the PolicyRepository. ") |
|
] |
|
CIM_PolicyCondition REF Dependent; |
|
}; |
|
|
|
// ================================================================== |
|
// PolicyActionInPolicyRepository *** deprecated |
|
// ================================================================== |
|
[Association, DEPRECATED {"CIM_ReusablePolicy"}, |
|
Description ( |
|
"The ReusablePolicy association is a more general relationship " |
|
"that incorporates both Conditions and Actions as well as any " |
|
"other policy subclass.\n" |
|
"\n" |
|
"A class representing the hosting of reusable " |
|
"PolicyActions by a PolicyRepository. A reusable Policy" |
|
"Action is always related to a single PolicyRepository, " |
|
"via this association.\n\n" |
|
" " |
|
"Note, that an instance of PolicyAction can be either " |
|
"reusable or rule-specific. When the Action is rule-" |
|
"specific, it shall not be related to any " |
|
"PolicyRepository via the PolicyActionInPolicyRepository " |
|
"association.") |
|
] |
|
class CIM_PolicyActionInPolicyRepository : CIM_PolicyInSystem |
|
{ |
|
[Override ("Antecedent"), Max(1), Description ( |
|
"This property represents a PolicyRepository " |
|
"hosting one or more PolicyActions. A reusable " |
|
"PolicyAction is always related to exactly one " |
|
"PolicyRepository via the PolicyActionInPolicyRepository " |
|
"association. The [0..1] cardinality for this property " |
|
"covers the two types of PolicyActions: 0 for a " |
|
"rule-specific PolicyAction, 1 for a reusable one.") |
|
] |
|
CIM_PolicyRepository REF Antecedent; |
|
[Override ("Dependent"), Description ( |
|
"This property holds the name of a PolicyAction" |
|
"hosted in the PolicyRepository. ") |
|
] |
|
CIM_PolicyAction REF Dependent; |
|
}; |
|
|
|
|
|
// =================================================================== |
|
// end of file |
|
// =================================================================== |
|
|
|
|