1 // ==================================================================
\r
2 // Title: Policy MOF Specification 2.6
\r
3 // Filename: CIM_Policy26.MOF
\r
7 // ===================================================================
\r
8 // Copyright 2000-2002 Distributed Management Task Force, Inc. (DMTF).
\r
9 // All rights reserved.
\r
10 // DMTF is a not-for-profit association of industry members dedicated
\r
11 // to promoting enterprise and systems management and interoperability.
\r
12 // DMTF specifications and documents may be reproduced for uses
\r
13 // consistent with this purpose by members and non-members,
\r
14 // provided that correct attribution is given.
\r
15 // As DMTF specifications may be revised from time to time,
\r
16 // the particular version and release date should always be noted.
\r
18 // Implementation of certain elements of this standard or proposed
\r
19 // standard may be subject to third party patent rights, including
\r
20 // provisional patent rights (herein "patent rights"). DMTF makes
\r
21 // no representations to users of the standard as to the existence
\r
22 // of such rights, and is not responsible to recognize, disclose, or
\r
23 // identify any or all such third party patent right, owners or
\r
24 // claimants, nor for any incomplete or inaccurate identification or
\r
25 // disclosure of such rights, owners or claimants. DMTF shall have no
\r
26 // liability to any party, in any manner or circumstance, under any
\r
27 // legal theory whatsoever, for failure to recognize, disclose, or
\r
28 // identify any such third party patent rights, or for such party
\92s
\r
29 // reliance on the standard or incorporation thereof in its product,
\r
30 // protocols or testing procedures. DMTF shall have no liability to
\r
31 // any party implementing such standard, whether such implementation
\r
32 // is foreseeable or not, nor to any patent owner or claimant, and shall
\r
33 // have no liability or responsibility for costs or losses incurred if
\r
34 // a standard is withdrawn or modified after publication, and shall be
\r
35 // indemnified and held harmless by any party implementing the
\r
36 // standard from any and all claims of infringement by a patent owner
\r
37 // for such implementations.
\r
39 // For information about patents held by third-parties which have
\r
40 // notified the DMTF that, in their opinion, such patent may relate to
\r
41 // or impact implementations of DMTF standards, visit
\r
42 // http://www.dmtf.org/about/policies/disclosures.php.
\r
43 // ===================================================================
\r
44 // Description: The Policy Model provides a framework for specifying
\r
45 // configuration and operational information in a scalable
\r
46 // way using rules composed of conditions and actions.
\r
48 // The object classes below are listed in an order that
\r
49 // avoids forward references. Required objects, defined
\r
50 // by other working groups, are omitted.
\r
51 // ===================================================================
\r
52 // CIMCR614 - Add CompoundPolicyAction for CIM 2.6
\r
53 // - Add CompoundPolicyAction as a subclass of PolicyAction
\r
54 // - Add PolicyActionStructure abstract aggregation as a
\r
55 // subclass of PolicyComponent
\r
56 // - Change derivation of PolicyActionInPolicyRule from
\r
57 // PolicyComponent to PolicyActionStructure and, thus,
\r
58 // move ActionOrder property up to parent class
\r
59 // - Add PolicyActionInPolicyAction aggregation as a
\r
60 // subclass of PolicyActionStructure
\r
62 // CIMCR597a - PCIMe updates for 2.6
\r
63 // - Edit Policy description
\r
64 // - Add PolicySet & derive PolicyGroup & PolicyRule
\r
65 // - Deprecate PolicyRule.Priority for
\r
66 // PolicySetComponent.Priority
\r
67 // - Remove PolicyRule.PolicyRoles (it's in PolicySet)
\r
68 // - Add PolicyRule.ExecutionStrategy
\r
69 // - Deprecate PolicyRepository & replace with
\r
70 // ReusablePolicyContainer
\r
71 // - Add PolicySetInSystem
\r
72 // - Add PolicySetComponent & deprecate ...InPolicyGroup
\r
73 // & derive PolicyGroupInSystem & PolicyRuleInSystem
\r
74 // - Add ContainedDomain (to Core)
\r
75 // & deprecate PolicyRepositoryInPolicyRepository
\r
76 // - Add ReusablePolicy & deprecate ...InPolicyRepository
\r
78 // CIMCR516a - Rooted the model associations under Policy
\r
79 // Component or PolicyInSystem. Corrected PolicyCondition/
\r
80 // PolicyActionInPolicyRepository to subclass from
\r
81 // PolicyInSystem (similar to Groups and Roles 'InSystem')
\r
83 // CIMCR746 - Add the Version ("2.6.0") qualifier
\r
85 // ==================================================================
\r
87 // ==================================================================
\r
89 // ==================================================================
\r
90 #pragma Locale ("en-US")
\r
92 // ==================================================================
\r
94 // ==================================================================
\r
95 [Abstract, Version ("2.6.0"), Description (
\r
96 "An abstract class defining the common properties of the policy "
\r
97 "managed elements derived from CIM_Policy. The subclasses are "
\r
98 "used to create rules and groups of rules that work together to "
\r
99 "form a coherent set of policies within an administrative domain "
\r
100 "or set of domains.") ]
\r
101 class CIM_Policy : CIM_ManagedElement {
\r
103 "A user-friendly name of this policy-related object.") ]
\r
106 "An array of keywords for characterizing / categorizing "
\r
107 "policy objects. Keywords are of one of two types: \n"
\r
108 "- Keywords defined in this and other MOFs, or in DMTF"
\r
109 "white papers. These keywords provide a vendor-"
\r
110 "independent, installation-independent way of "
\r
111 "characterizing policy objects. \n"
\r
112 "- Installation-dependent keywords for characterizing "
\r
113 "policy objects. Examples include 'Engineering', "
\r
114 "'Billing', and 'Review in December 2000'. \n"
\r
115 "This MOF defines the following keywords: 'UNKNOWN', "
\r
116 "'CONFIGURATION', 'USAGE', 'SECURITY', 'SERVICE', "
\r
117 "'MOTIVATIONAL', 'INSTALLATION', and 'EVENT'. These "
\r
118 "concepts are self-explanatory and are further discussed "
\r
119 "in the SLA/Policy White Paper. One additional keyword "
\r
120 "is defined: 'POLICY'. The role of this keyword is to "
\r
121 "identify policy-related instances that may not be otherwise "
\r
122 "identifiable, in some implementations. The keyword 'POLICY' "
\r
123 "is NOT mutually exclusive of the other keywords "
\r
124 "specified above.") ]
\r
125 string PolicyKeywords[];
\r
129 // ==================================================================
\r
131 // ==================================================================
\r
132 [Abstract, Version ("2.6.0"),
\r
133 Description ("PolicySet is an abstract class that "
\r
134 "represents a set of policies that form a coherent set. The "
\r
135 "set of contained policies has a common decision strategy and "
\r
136 "a common set of policy roles. Subclasses include "
\r
137 "PolicyGroup and PolicyRule.") ]
\r
138 class CIM_PolicySet : CIM_Policy {
\r
139 [Description ("PolicyDecisionStrategy defines the evaluation "
\r
140 "method used for policies contained in the PolicySet. "
\r
141 "FirstMatching enforces the actions of the first rule that "
\r
142 "evaluates to TRUE. It is the only value currently defined."),
\r
144 Values {"FirstMatching"} ]
\r
145 uint16 PolicyDecisionStrategy;
\r
147 "The PolicyRoles property represents the roles and role "
\r
148 "combinations associated with a PolicySet. All contained "
\r
149 "PolicySet instances inherit the values of the PolicyRoles of "
\r
150 "the aggregating PolicySet but the values are not copied. "
\r
151 "A contained PolicySet instance may, however, add additional "
\r
152 "PolicyRoles to those it inherits from its aggregating "
\r
155 "Each value represents one role or role combination. Since "
\r
156 "this is a multi-valued property, more than one role or "
\r
157 "combination can be associated with a single PolicySet. Each "
\r
158 "value is a string of the form: \n"
\r
159 " <RoleName>[&&<RoleName>]* \n"
\r
160 "where the individual role names appear in alphabetical order "
\r
161 "(according to the collating sequence for UCS-2).") ]
\r
162 string PolicyRoles[];
\r
166 // ==================================================================
\r
168 // ==================================================================
\r
169 [Version ("2.6.0"), Description (
\r
170 "An aggregation of PolicySet instances (PolicyGroups and/or "
\r
171 "PolicyRules) that have the same decision strategy and inherit "
\r
172 "policy roles. PolicyGroup instances are defined and named "
\r
173 "relative to the CIM_System that provides their context.") ]
\r
174 class CIM_PolicyGroup : CIM_PolicySet {
\r
175 [Propagated("CIM_System.CreationClassName"),
\r
177 Description ("The scoping System's CreationClassName.") ]
\r
178 string SystemCreationClassName;
\r
179 [Propagated("CIM_System.Name"),
\r
181 Description ("The scoping System's Name.") ]
\r
183 [Key, MaxLen (256), Description (
\r
184 "CreationClassName indicates the name of the class or the "
\r
185 "subclass used in the creation of an instance. When used "
\r
186 "with the other key properties of this class, this property "
\r
187 "allows all instances of this class and its subclasses to "
\r
188 "be uniquely identified.") ]
\r
189 string CreationClassName;
\r
190 [Key, MaxLen (256), Description (
\r
191 "A user-friendly name of this PolicyGroup.") ]
\r
192 string PolicyGroupName;
\r
196 // ==================================================================
\r
198 // ==================================================================
\r
199 [Version ("2.6.0"), Description (
\r
200 "The central class used for representing the 'If Condition then "
\r
201 "Action' semantics of a policy rule. A PolicyRule condition, in "
\r
202 "the most general sense, is represented as either an ORed set of "
\r
203 "ANDed conditions (Disjunctive Normal Form, or DNF) or an ANDed "
\r
204 "set of ORed conditions (Conjunctive Normal Form, or CNF). "
\r
205 "Individual conditions may either be negated (NOT C) or "
\r
206 "unnegated (C). The actions specified by a PolicyRule are to be "
\r
207 "performed if and only if the PolicyRule condition (whether it "
\r
208 "is represented in DNF or CNF) evaluates to TRUE. \n"
\r
210 "The conditions and actions associated with a PolicyRule are "
\r
211 "modeled, respectively, with subclasses of PolicyCondition and "
\r
212 "PolicyAction. These condition and action objects are tied to "
\r
213 "instances of PolicyRule by the PolicyConditionInPolicyRule and "
\r
214 "PolicyActionInPolicyRule aggregations. \n"
\r
216 "A PolicyRule may also be associated with one or more policy "
\r
217 "time periods, indicating the schedule according to which the "
\r
218 "policy rule is active and inactive. In this case it is the "
\r
219 "PolicyRuleValidityPeriod aggregation that provides this "
\r
222 "The PolicyRule class uses the property ConditionListType, to "
\r
223 "indicate whether the conditions for the rule are in DNF or "
\r
224 "CNF. The PolicyConditionInPolicyRule aggregation contains "
\r
225 "two additional properties to complete the representation of "
\r
226 "the Rule's conditional expression. The first of these "
\r
227 "properties is an integer to partition the referenced "
\r
228 "PolicyConditions into one or more groups, and the second is a "
\r
229 "Boolean to indicate whether a referenced Condition is "
\r
230 "negated. An example shows how ConditionListType and these "
\r
231 "two additional properties provide a unique representation "
\r
232 "of a set of PolicyConditions in either DNF or CNF. \n"
\r
234 "Suppose we have a PolicyRule that aggregates five "
\r
235 "PolicyConditions C1 through C5, with the following values "
\r
236 "in the properties of the five PolicyConditionInPolicyRule "
\r
238 " C1: GroupNumber = 1, ConditionNegated = FALSE \n"
\r
239 " C2: GroupNumber = 1, ConditionNegated = TRUE \n"
\r
240 " C3: GroupNumber = 1, ConditionNegated = FALSE \n"
\r
241 " C4: GroupNumber = 2, ConditionNegated = FALSE \n"
\r
242 " C5: GroupNumber = 2, ConditionNegated = FALSE \n"
\r
244 "If ConditionListType = DNF, then the overall condition for "
\r
245 "the PolicyRule is: \n"
\r
246 " (C1 AND (NOT C2) AND C3) OR (C4 AND C5) \n"
\r
248 "On the other hand, if ConditionListType = CNF, then the "
\r
249 "overall condition for the PolicyRule is: \n"
\r
250 " (C1 OR (NOT C2) OR C3) AND (C4 OR C5) \n"
\r
252 "In both cases, there is an unambiguous specification of "
\r
253 "the overall condition that is tested to determine whether "
\r
254 "to perform the PolicyActions associated with the PolicyRule. \n"
\r
256 "PolicyRule instances may also be used to aggregate other "
\r
257 "PolicyRules and/or PolicyGroups. When used in this way to "
\r
258 "implement nested rules, the conditions of the aggregating rule "
\r
259 "apply to the subordinate rules as well. However, any side "
\r
260 "effects of condition evaluation or the execution of actions MUST "
\r
261 "NOT affect the result of the evaluation of other conditions "
\r
262 "evaluated by the rule engine in the same evaluation pass. That "
\r
263 "is, an implementation of a rule engine MAY evaluate all "
\r
264 "conditions in any order before applying the priority and "
\r
265 "determining which actions are to be executed.") ]
\r
266 class CIM_PolicyRule : CIM_PolicySet {
\r
267 [Propagated("CIM_System.CreationClassName"),
\r
269 Description ("The scoping System's CreationClassName.") ]
\r
270 string SystemCreationClassName;
\r
271 [Propagated("CIM_System.Name"),
\r
273 Description ("The scoping System's Name.") ]
\r
275 [Key, MaxLen (256), Description (
\r
276 "CreationClassName indicates the name of the class or the "
\r
277 "subclass used in the creation of an instance. When used "
\r
278 "with the other key properties of this class, this property "
\r
279 "allows all instances of this class and its subclasses to "
\r
280 "be uniquely identified.") ]
\r
281 string CreationClassName;
\r
282 [Key, MaxLen (256), Description (
\r
283 "A user-friendly name of this PolicyRule.") ]
\r
284 string PolicyRuleName;
\r
286 "Indicates whether this PolicyRule is administratively "
\r
287 "enabled, administratively disabled, or enabled for "
\r
288 "debug. When the property has the value 3 (\"enabledFor"
\r
289 "Debug\"), the entity evaluating the PolicyConditions is "
\r
290 "instructed to evaluate the conditions for the Rule, but not "
\r
291 "to perform the actions if the PolicyConditions evaluate to "
\r
292 "TRUE. This serves as a debug vehicle when attempting to "
\r
293 "determine what policies would execute in a particular "
\r
294 "scenario, without taking any actions to change state "
\r
295 "during the debugging. The default value is 1 "
\r
297 ValueMap {"1", "2", "3"},
\r
298 Values {"Enabled", "Disabled", "EnabledForDebug"} ]
\r
301 "Indicates whether the list of PolicyConditions "
\r
302 "associated with this PolicyRule is in disjunctive "
\r
303 "normal form (DNF) or conjunctive normal form (CNF)."
\r
304 "The default value is 1 (\"DNF\")."),
\r
305 ValueMap {"1", "2"},
\r
306 Values {"DNF", "CNF"} ]
\r
307 uint16 ConditionListType;
\r
309 "A free-form string that can be used to provide "
\r
310 "guidelines on how this PolicyRule should be used.") ]
\r
312 [DEPRECATED {"CIM_PolicySetComponent.Priority"},
\r
314 "PolicyRule.Priority is deprecated and replaced by "
\r
315 "providing the priority for a rule (and a group) in the "
\r
316 "context of the aggregating PolicySet instead of the "
\r
317 "priority being used for all aggregating PolicySet "
\r
318 "instances. Thus, the assignment of priority values is "
\r
321 "A non-negative integer for prioritizing this Policy"
\r
322 "Rule relative to other Rules. A larger value "
\r
323 "indicates a higher priority. The default value is 0.") ]
\r
326 "A flag indicating that the evaluation of the Policy"
\r
327 "Conditions and execution of PolicyActions (if the "
\r
328 "Conditions evaluate to TRUE) is required. The "
\r
329 "evaluation of a PolicyRule MUST be attempted if the "
\r
330 "Mandatory property value is TRUE. If the Mandatory "
\r
331 "property is FALSE, then the evaluation of the Rule "
\r
332 "is 'best effort' and MAY be ignored.") ]
\r
335 "This property gives a policy administrator a way "
\r
336 "of specifying how the ordering of the PolicyActions "
\r
337 "associated with this PolicyRule is to be interpreted. "
\r
338 "Three values are supported: \n"
\r
339 " o mandatory(1): Do the actions in the indicated "
\r
340 " order, or don't do them at all. \n"
\r
341 " o recommended(2): Do the actions in the indicated "
\r
342 " order if you can, but if you can't do them in this "
\r
343 " order, do them in another order if you can. \n"
\r
344 " o dontCare(3): Do them -- I don't care about the "
\r
346 "The default value is 3 (\"DontCare\")."),
\r
347 ValueMap {"1", "2", "3"},
\r
348 Values {"Mandatory", "Recommended", "DontCare"} ]
\r
349 uint16 SequencedActions;
\r
351 "ExecutionStrategy defines the strategy to be used in "
\r
352 "executing the sequenced actions aggregated by this "
\r
353 "PolicyRule. There are three execution strategies: \n"
\r
355 "Do Until Success - execute actions according to predefined \n"
\r
356 " order, until successful execution of a \n"
\r
357 " single action. \n"
\r
358 "Do All - execute ALL actions which are part of \n"
\r
359 " the modeled set, according to their \n"
\r
360 " predefined order. Continue doing this, \n"
\r
361 " even if one or more of the actions fails. \n"
\r
362 "Do Until Failure - execute actions according to predefined \n"
\r
363 " order, until the first failure in \n"
\r
364 " execution of an action instance."),
\r
365 ValueMap {"1", "2", "3"},
\r
366 Values {"Do Until Success", "Do All", "Do Until Failure"} ]
\r
367 uint16 ExecutionStrategy;
\r
371 // ==================================================================
\r
372 // ReusablePolicyContainer
\r
373 // ==================================================================
\r
374 [Version ("2.6.0"), Description (
\r
375 "A class representing an administratively defined "
\r
376 "container for reusable policy-related information. "
\r
377 "This class does not introduce any additional "
\r
378 "properties beyond those in its superclass "
\r
379 "AdminDomain. It does, however, participate in a "
\r
380 "unique association for containing policy elements. \n"
\r
382 "An instance of this class uses the NameFormat value"
\r
383 "\"ReusablePolicyContainer\".") ]
\r
384 class CIM_ReusablePolicyContainer : CIM_AdminDomain {
\r
388 // ==================================================================
\r
389 // PolicyRepository *** deprecated
\r
390 // ==================================================================
\r
391 [DEPRECATED{"CIM_ReusablePolicyContainer"},
\r
392 Version ("2.6.0"), Description (
\r
393 "The term 'PolicyRepository' has been confusing to both "
\r
394 "developers and users of the model. The replacement class "
\r
395 "name describes model element properly and is less likely "
\r
396 "to be confused with a data repository. \n"
\r
398 "A class representing an administratively defined "
\r
399 "container for reusable policy-related information. "
\r
400 "This class does not introduce any additional "
\r
401 "properties beyond those in its superclass "
\r
402 "AdminDomain. It does, however, participate in a "
\r
403 "number of unique associations. \n"
\r
405 "An instance of this class uses the NameFormat value"
\r
406 "\"PolicyRepository\".") ]
\r
407 class CIM_PolicyRepository : CIM_AdminDomain {
\r
411 // ==================================================================
\r
413 // ==================================================================
\r
414 [Abstract, Version ("2.6.0"), Description (
\r
415 "A class representing a rule-specific or reusable policy "
\r
416 "condition to be evaluated in conjunction with a Policy"
\r
417 "Rule. Since all operational details of a PolicyCondition "
\r
418 "are provided in subclasses of this object, this class is "
\r
420 class CIM_PolicyCondition : CIM_Policy {
\r
421 [Key, MaxLen (256), Description (
\r
422 " The name of the class or the subclass used in the "
\r
423 "creation of the System object in whose scope this "
\r
424 "PolicyCondition is defined. \n"
\r
426 "This property helps to identify the System object in "
\r
427 "whose scope this instance of PolicyCondition exists. "
\r
428 "For a rule-specific PolicyCondition, this is the System "
\r
429 "in whose context the PolicyRule is defined. For a "
\r
430 "reusable PolicyCondition, this is the instance of "
\r
431 "PolicyRepository (which is a subclass of System) that "
\r
432 "holds the Condition. \n"
\r
434 "Note that this property, and the analogous property "
\r
435 "SystemName, do not represent propagated keys from an "
\r
436 "instance of the class System. Instead, they are "
\r
437 "properties defined in the context of this class, which "
\r
438 "repeat the values from the instance of System to which "
\r
439 "this PolicyCondition is related, either directly via the "
\r
440 "PolicyConditionInPolicyRepository association or indirectly "
\r
441 "via the PolicyConditionInPolicyRule aggregation.") ]
\r
442 string SystemCreationClassName;
\r
443 [Key, MaxLen (256), Description (
\r
444 "The name of the System object in whose scope this "
\r
445 "PolicyCondition is defined. \n"
\r
447 "This property completes the identification of the System "
\r
448 "object in whose scope this instance of PolicyCondition "
\r
449 "exists. For a rule-specific PolicyCondition, this is the "
\r
450 "System in whose context the PolicyRule is defined. For a "
\r
451 "reusable PolicyCondition, this is the instance of "
\r
452 "PolicyRepository (which is a subclass of System) that "
\r
453 "holds the Condition.") ]
\r
455 [Key, MaxLen (256), Description (
\r
456 "For a rule-specific PolicyCondition, the "
\r
457 "CreationClassName of the PolicyRule object with which "
\r
458 "this Condition is associated. For a reusable Policy"
\r
459 "Condition, a special value, 'NO RULE', should be used to "
\r
460 "indicate that this Condition is reusable and not "
\r
461 "associated with a single PolicyRule.") ]
\r
462 string PolicyRuleCreationClassName;
\r
463 [Key, MaxLen (256), Description (
\r
464 "For a rule-specific PolicyCondition, the name of "
\r
465 "the PolicyRule object with which this Condition is "
\r
466 "associated. For a reusable PolicyCondition, a "
\r
467 "special value, 'NO RULE', should be used to indicate "
\r
468 "that this Condition is reusable and not associated "
\r
469 "with a single PolicyRule.") ]
\r
470 string PolicyRuleName;
\r
471 [Key, MaxLen (256), Description (
\r
472 "CreationClassName indicates the name of the class or the "
\r
473 "subclass used in the creation of an instance. When used "
\r
474 "with the other key properties of this class, this property "
\r
475 "allows all instances of this class and its subclasses to "
\r
476 "be uniquely identified.") ]
\r
477 string CreationClassName;
\r
478 [Key, MaxLen (256), Description (
\r
479 "A user-friendly name of this PolicyCondition.") ]
\r
480 string PolicyConditionName;
\r
484 // ==================================================================
\r
485 // PolicyTimePeriodCondition
\r
486 // ==================================================================
\r
487 [Version ("2.6.0"), Description (
\r
488 "This class provides a means of representing the time "
\r
489 "periods during which a PolicyRule is valid, i.e., active. "
\r
490 "At all times that fall outside these time periods, the "
\r
491 "PolicyRule has no effect. A Rule is treated as valid "
\r
492 "at ALL times, if it does not specify a "
\r
493 "PolicyTimePeriodCondition. \n"
\r
495 "In some cases a Policy Consumer may need to perform "
\r
496 "certain setup / cleanup actions when a PolicyRule becomes "
\r
497 "active / inactive. For example, sessions that were "
\r
498 "established while a Rule was active might need to "
\r
499 "be taken down when the Rule becomes inactive. In other "
\r
500 "cases, however, such sessions might be left up. In this "
\r
501 "case, the effect of deactivating the PolicyRule would "
\r
502 "just be to prevent the establishment of new sessions. \n"
\r
504 "Setup / cleanup behaviors on validity period "
\r
505 "transitions are not currently addressed by the Policy "
\r
506 "Model, and must be specified in 'guideline' documents or "
\r
507 "via subclasses of CIM_PolicyRule, CIM_PolicyTimePeriod"
\r
508 "Condition or other concrete subclasses of CIM_Policy. If "
\r
509 "such behaviors need to be under the control of the policy "
\r
510 "administrator, then a mechanism to allow this control "
\r
511 "must also be specified in the subclasses. \n"
\r
513 "PolicyTimePeriodCondition is defined as a subclass of "
\r
514 "PolicyCondition. This is to allow the inclusion of "
\r
515 "time-based criteria in the AND/OR condition definitions "
\r
516 "for a PolicyRule. \n"
\r
518 "Instances of this class may have up to five properties "
\r
519 "identifying time periods at different levels. The values "
\r
520 "of all the properties present in an instance are ANDed "
\r
521 "together to determine the validity period(s) for the "
\r
522 "instance. For example, an instance with an overall "
\r
523 "validity range of January 1, 2000 through December 31, "
\r
524 "2000; a month mask that selects March and April; a "
\r
525 "day-of-the-week mask that selects Fridays; and a time "
\r
526 "of day range of 0800 through 1600 would be represented "
\r
527 "using the following time periods: \n"
\r
528 " Friday, March 5, 2000, from 0800 through 1600; \n "
\r
529 " Friday, March 12, 2000, from 0800 through 1600; \n "
\r
530 " Friday, March 19, 2000, from 0800 through 1600; \n "
\r
531 " Friday, March 26, 2000, from 0800 through 1600; \n "
\r
532 " Friday, April 2, 2000, from 0800 through 1600; \n "
\r
533 " Friday, April 9, 2000, from 0800 through 1600; \n "
\r
534 " Friday, April 16, 2000, from 0800 through 1600; \n "
\r
535 " Friday, April 23, 2000, from 0800 through 1600; \n "
\r
536 " Friday, April 30, 2000, from 0800 through 1600. \n"
\r
538 "Properties not present in an instance of "
\r
539 "PolicyTimePeriodCondition are implicitly treated as having "
\r
540 "their value 'always enabled'. Thus, in the example above, "
\r
541 "the day-of-the-month mask is not present, and so the "
\r
542 "validity period for the instance implicitly includes a "
\r
543 "day-of-the-month mask that selects all days of the month. "
\r
544 "If this 'missing property' rule is applied to its fullest, we "
\r
545 "see that there is a second way to indicate that a Policy"
\r
546 "Rule is always enabled: associate with it an instance of "
\r
547 "PolicyTimePeriodCondition whose only properties with "
\r
548 "specific values are its key properties.") ]
\r
549 class CIM_PolicyTimePeriodCondition : CIM_PolicyCondition {
\r
551 "This property identifies an overall range of calendar "
\r
552 "dates and times over which a PolicyRule is valid. It is "
\r
553 "formatted as a string representing a start date and time, "
\r
554 "in which the character 'T' indicates the beginning of the "
\r
555 "time portion, followed by the solidus character '/', "
\r
556 "followed by a similar string representing an end date and "
\r
557 "time. The first date indicates the beginning of the range, "
\r
558 "while the second date indicates the end. Thus, the second "
\r
559 "date and time must be later than the first. Date/times are "
\r
560 "expressed as substrings of the form yyyymmddThhmmss. For "
\r
562 " 20000101T080000/20000131T120000 defines \n"
\r
563 " January 1, 2000, 0800 through January 31, 2000, noon \n"
\r
565 "There are also two special cases in which one of the "
\r
566 "date/time strings is replaced with a special string defined "
\r
568 " o If the first date/time is replaced with the string "
\r
569 " 'THISANDPRIOR', then the property indicates that a "
\r
570 " PolicyRule is valid [from now] until the date/time "
\r
571 " that appears after the '/'. \n"
\r
572 " o If the second date/time is replaced with the string "
\r
573 " 'THISANDFUTURE', then the property indicates that a "
\r
574 " PolicyRule becomes valid on the date/time that "
\r
575 " appears before the '/', and remains valid from that "
\r
577 ModelCorrespondence {
\r
578 "CIM_PolicyTimePeriodCondition.MonthOfYearMask",
\r
579 "CIM_PolicyTimePeriodCondition.DayOfMonthMask",
\r
580 "CIM_PolicyTimePeriodCondition.DayOfWeekMask",
\r
581 "CIM_PolicyTimePeriodCondition.TimeOfDayMask",
\r
582 "CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} ]
\r
584 [Octetstring, Description (
\r
585 "The purpose of this property is to refine the valid time "
\r
586 "period that is defined by the TimePeriod property, by "
\r
587 "explicitly specifying in which months the PolicyRule is "
\r
588 "valid. These properties work together, with the "
\r
589 "TimePeriod used to specify the overall time period in "
\r
590 "which the PolicyRule is valid, and the MonthOfYearMask used "
\r
591 "to pick out the months during which the Rule is valid. \n"
\r
593 "This property is formatted as an octet string, structured "
\r
595 " o a 4-octet length field, indicating the length of the "
\r
596 " entire octet string; this field is always set to "
\r
597 " 0x00000006 for this property; \n"
\r
598 " o a 2-octet field consisting of 12 bits identifying the "
\r
599 " 12 months of the year, beginning with January and "
\r
600 " ending with December, followed by 4 bits that are "
\r
601 " always set to '0'. For each month, the value '1' "
\r
602 " indicates that the policy is valid for that month, "
\r
603 " and the value '0' indicates that it is not valid. \n"
\r
605 "The value 0x000000060830, for example, indicates that a "
\r
606 "PolicyRule is valid only in the months May, November, "
\r
609 "If a value for this property is not provided, then the "
\r
610 "PolicyRule is treated as valid for all twelve months, and "
\r
611 "only restricted by its TimePeriod property value and the "
\r
612 "other Mask properties."),
\r
613 ModelCorrespondence {
\r
614 "CIM_PolicyTimePeriodCondition.TimePeriod",
\r
615 "CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} ]
\r
616 uint8 MonthOfYearMask[];
\r
617 [Octetstring, Description (
\r
618 "The purpose of this property is to refine the valid time "
\r
619 "period that is defined by the TimePeriod property, by "
\r
620 "explicitly specifying in which days of the month the Policy"
\r
621 "Rule is valid. These properties work together, "
\r
622 "with the TimePeriod used to specify the overall time period "
\r
623 "in which the PolicyRule is valid, and the DayOfMonthMask used "
\r
624 "to pick out the days of the month during which the Rule "
\r
627 "This property is formatted as an octet string, structured "
\r
629 " o a 4-octet length field, indicating the length of the "
\r
630 " entire octet string; this field is always set to "
\r
631 " 0x0000000C for this property; \n"
\r
632 " o an 8-octet field consisting of 31 bits identifying "
\r
633 " the days of the month counting from the beginning, "
\r
634 " followed by 31 more bits identifying the days of the "
\r
635 " month counting from the end, followed by 2 bits that "
\r
636 " are always set to '0'. For each day, the value '1' "
\r
637 " indicates that the policy is valid for that day, and "
\r
638 " the value '0' indicates that it is not valid. \n"
\r
640 "The value 0x0000000C8000000100000000, for example, "
\r
641 "indicates that a PolicyRule is valid on the first and "
\r
642 "last days of the month. \n"
\r
644 "For months with fewer than 31 days, the digits corresponding "
\r
645 "to days that the months do not have (counting in both "
\r
646 "directions) are ignored. \n"
\r
648 "If a value for this property is not provided, then the "
\r
649 "PolicyRule is treated as valid for all days of the month, and "
\r
650 "only restricted by its TimePeriod property value and the "
\r
651 "other Mask properties."),
\r
652 ModelCorrespondence {
\r
653 "CIM_PolicyTimePeriodCondition.TimePeriod",
\r
654 "CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} ]
\r
655 uint8 DayOfMonthMask[];
\r
656 [Octetstring, Description (
\r
657 "The purpose of this property is to refine the valid time "
\r
658 "period that is defined by the TimePeriod property, by "
\r
659 "explicitly specifying in which days of the month the Policy"
\r
660 "Rule is valid. These properties work together, "
\r
661 "with the TimePeriod used to specify the overall time period "
\r
662 "in which the PolicyRule is valid, and the DayOfWeekMask used "
\r
663 "to pick out the days of the week during which the Rule "
\r
666 "This property is formatted as an octet string, structured "
\r
668 " o a 4-octet length field, indicating the length of the "
\r
669 " entire octet string; this field is always set to "
\r
670 " 0x00000005 for this property; \n"
\r
671 " o a 1-octet field consisting of 7 bits identifying the 7 "
\r
672 " days of the week, beginning with Sunday and ending with "
\r
673 " Saturday, followed by 1 bit that is always set to '0'. "
\r
674 " For each day of the week, the value '1' indicates that "
\r
675 " the policy is valid for that day, and the value '0' "
\r
676 " indicates that it is not valid. \n"
\r
678 "The value 0x000000057C, for example, indicates that a "
\r
679 "PolicyRule is valid Monday through Friday. \n"
\r
681 "If a value for this property is not provided, then the "
\r
682 "PolicyRule is treated as valid for all days of the week, "
\r
683 "and only restricted by its TimePeriod property value and "
\r
684 "the other Mask properties."),
\r
685 ModelCorrespondence {
\r
686 "CIM_PolicyTimePeriodCondition.TimePeriod",
\r
687 "CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} ]
\r
688 uint8 DayOfWeekMask[];
\r
690 "The purpose of this property is to refine the valid time "
\r
691 "period that is defined by the TimePeriod property, by "
\r
692 "explicitly specifying a range of times in a day during which "
\r
693 "the PolicyRule is valid. These properties work "
\r
694 "together, with the TimePeriod used to specify the overall "
\r
695 "time period in which the PolicyRule is valid, and the "
\r
696 "TimeOfDayMask used to pick out the range of time periods "
\r
697 "in a given day of during which the Rule is valid. \n"
\r
699 "This property is formatted in the style of RFC 2445: a "
\r
700 "time string beginning with the character 'T', followed by "
\r
701 "the solidus character '/', followed by a second time string. "
\r
702 "The first time indicates the beginning of the range, while "
\r
703 "the second time indicates the end. Times are expressed as "
\r
704 "substrings of the form 'Thhmmss'. \n"
\r
706 "The second substring always identifies a later time than "
\r
707 "the first substring. To allow for ranges that span "
\r
708 "midnight, however, the value of the second string may be "
\r
709 "smaller than the value of the first substring. Thus, "
\r
710 "'T080000/T210000' identifies the range from 0800 until 2100, "
\r
711 "while 'T210000/T080000' identifies the range from 2100 until "
\r
712 "0800 of the following day. \n"
\r
714 "When a range spans midnight, it by definition includes "
\r
715 "parts of two successive days. When one of these days is "
\r
716 "also selected by either the MonthOfYearMask, "
\r
717 "DayOfMonthMask, and/or DayOfWeekMask, but the other day is "
\r
718 "not, then the policy is active only during the portion of "
\r
719 "the range that falls on the selected day. For example, if "
\r
720 "the range extends from 2100 until 0800, and the day of "
\r
721 "week mask selects Monday and Tuesday, then the policy is "
\r
722 "active during the following three intervals: \n"
\r
723 " From midnight Sunday until 0800 Monday; \n"
\r
724 " From 2100 Monday until 0800 Tuesday; \n"
\r
725 " From 2100 Tuesday until 23:59:59 Tuesday. \n"
\r
727 "If a value for this property is not provided, then the "
\r
728 "PolicyRule is treated as valid for all hours of the day, "
\r
729 "and only restricted by its TimePeriod property value and "
\r
730 "the other Mask properties."),
\r
731 ModelCorrespondence {
\r
732 "CIM_PolicyTimePeriodCondition.TimePeriod",
\r
733 "CIM_PolicyTimePeriodCondition.LocalOrUtcTime"} ]
\r
734 string TimeOfDayMask;
\r
736 "This property indicates whether the times represented "
\r
737 "in the TimePeriod property and in the various Mask "
\r
738 "properties represent local times or UTC times. There is "
\r
739 "no provision for mixing of local times and UTC times: the "
\r
740 "value of this property applies to all of the other "
\r
741 "time-related properties."),
\r
742 ValueMap {"1", "2"},
\r
743 Values {"LocalTime", "UTCTime"},
\r
744 ModelCorrespondence {
\r
745 "CIM_PolicyTimePeriodCondition.TimePeriod",
\r
746 "CIM_PolicyTimePeriodCondition.MonthOfYearMask",
\r
747 "CIM_PolicyTimePeriodCondition.DayOfMonthMask",
\r
748 "CIM_PolicyTimePeriodCondition.DayOfWeekMask",
\r
749 "CIM_PolicyTimePeriodCondition.TimeOfDayMask"} ]
\r
750 uint16 LocalOrUtcTime;
\r
754 // ==================================================================
\r
755 // VendorPolicyCondition
\r
756 // ==================================================================
\r
757 [Version ("2.6.0"), Description (
\r
758 "A class that provides a general extension mechanism for "
\r
759 "representing PolicyConditions that have not been modeled "
\r
760 "with specific properties. Instead, the two properties "
\r
761 "Constraint and ConstraintEncoding are used to define the "
\r
762 "content and format of the Condition, as explained below. \n"
\r
764 "As its name suggests, VendorPolicyCondition is intended for "
\r
765 "vendor-specific extensions to the Policy Core Information "
\r
766 "Model. Standardized extensions are not expected to use "
\r
768 class CIM_VendorPolicyCondition : CIM_PolicyCondition {
\r
769 [Octetstring, Description (
\r
770 "This property provides a general extension mechanism for "
\r
771 "representing PolicyConditions that have not been "
\r
772 "modeled with specific properties. The format of the "
\r
773 "octet strings in the array is left unspecified in "
\r
774 "this definition. It is determined by the OID value "
\r
775 "stored in the property ConstraintEncoding. Since "
\r
776 "ConstraintEncoding is single-valued, all the values of "
\r
777 "Constraint share the same format and semantics."),
\r
778 ModelCorrespondence {
\r
779 "CIM_VendorPolicyCondition.ConstraintEncoding"} ]
\r
780 string Constraint[];
\r
782 "An OID encoded as a string, identifying the format "
\r
783 "and semantics for this instance's Constraint property."),
\r
784 ModelCorrespondence {
\r
785 "CIM_VendorPolicyCondition.Constraint"} ]
\r
786 string ConstraintEncoding;
\r
789 // ==================================================================
\r
791 // ==================================================================
\r
792 [Abstract, Version ("2.6.0"), Description (
\r
793 "A class representing a rule-specific or reusable policy "
\r
794 "action to be performed if the PolicyConditions for a Policy"
\r
795 "Rule evaluate to TRUE. Since all operational details of a "
\r
796 "PolicyAction are provided in subclasses of this object, "
\r
797 "this class is abstract.") ]
\r
798 class CIM_PolicyAction : CIM_Policy {
\r
799 [Key, MaxLen (256), Description (
\r
800 "The name of the class or the subclass used in the "
\r
801 "creation of the System object in whose scope this "
\r
802 "PolicyAction is defined. \n"
\r
804 "This property helps to identify the System object in "
\r
805 "whose scope this instance of PolicyAction exists. "
\r
806 "For a rule-specific PolicyAction, this is the System "
\r
807 "in whose context the PolicyRule is defined. For a "
\r
808 "reusable PolicyAction, this is the instance of "
\r
809 "PolicyRepository (which is a subclass of System) that "
\r
810 "holds the Action. \n"
\r
812 "Note that this property, and the analogous property "
\r
813 "SystemName, do not represent propagated keys from an "
\r
814 "instance of the class System. Instead, they are "
\r
815 "properties defined in the context of this class, which "
\r
816 "repeat the values from the instance of System to which "
\r
817 "this PolicyAction is related, either directly via the "
\r
818 "PolicyActionInPolicyRepository association or indirectly "
\r
819 "via the PolicyActionInPolicyRule aggregation.") ]
\r
820 string SystemCreationClassName;
\r
821 [Key, MaxLen (256), Description (
\r
822 "The name of the System object in whose scope this "
\r
823 "PolicyAction is defined. \n"
\r
825 "This property completes the identification of the System "
\r
826 "object in whose scope this instance of PolicyAction "
\r
827 "exists. For a rule-specific PolicyAction, this is the "
\r
828 "System in whose context the PolicyRule is defined. For "
\r
829 "a reusable PolicyAction, this is the instance of "
\r
830 "PolicyRepository (which is a subclass of System) that "
\r
831 "holds the Action.") ]
\r
833 [Key, MaxLen (256), Description (
\r
834 "For a rule-specific PolicyAction, the CreationClassName "
\r
835 "of the PolicyRule object with which this Action is "
\r
836 "associated. For a reusable PolicyAction, a "
\r
837 "special value, 'NO RULE', should be used to "
\r
838 "indicate that this Action is reusable and not "
\r
839 "associated with a single PolicyRule.") ]
\r
840 string PolicyRuleCreationClassName;
\r
841 [Key, MaxLen (256), Description (
\r
842 "For a rule-specific PolicyAction, the name of "
\r
843 "the PolicyRule object with which this Action is "
\r
844 "associated. For a reusable PolicyAction, a "
\r
845 "special value, 'NO RULE', should be used to "
\r
846 "indicate that this Action is reusable and not "
\r
847 "associated with a single PolicyRule.") ]
\r
848 string PolicyRuleName;
\r
849 [Key, MaxLen (256), Description (
\r
850 "CreationClassName indicates the name of the class or the "
\r
851 "subclass used in the creation of an instance. When used "
\r
852 "with the other key properties of this class, this property "
\r
853 "allows all instances of this class and its subclasses to "
\r
854 "be uniquely identified.") ]
\r
855 string CreationClassName;
\r
856 [Key, MaxLen (256), Description (
\r
857 "A user-friendly name of this PolicyAction.") ]
\r
858 string PolicyActionName;
\r
862 // ==================================================================
\r
863 // VendorPolicyAction
\r
864 // ==================================================================
\r
865 [Version ("2.6.0"), Description (
\r
866 "A class that provides a general extension mechanism for "
\r
867 "representing PolicyActions that have not been modeled "
\r
868 "with specific properties. Instead, the two properties "
\r
869 "ActionData and ActionEncoding are used to define the "
\r
870 "content and format of the Action, as explained below. \n"
\r
872 "As its name suggests, VendorPolicyAction is intended for "
\r
873 "vendor-specific extensions to the Policy Core Information "
\r
874 "Model. Standardized extensions are not expected to use "
\r
876 class CIM_VendorPolicyAction : CIM_PolicyAction {
\r
877 [Octetstring, Description (
\r
878 "This property provides a general extension mechanism for "
\r
879 "representing PolicyActions that have not been "
\r
880 "modeled with specific properties. The format of the "
\r
881 "octet strings in the array is left unspecified in "
\r
882 "this definition. It is determined by the OID value "
\r
883 "stored in the property ActionEncoding. Since "
\r
884 "ActionEncoding is single-valued, all the values of "
\r
885 "ActionData share the same format and semantics."),
\r
886 ModelCorrespondence {
\r
887 "CIM_VendorPolicyAction.ActionEncoding"} ]
\r
888 string ActionData[];
\r
890 "An OID encoded as a string, identifying the format "
\r
891 "and semantics for this instance's ActionData property."),
\r
892 ModelCorrespondence {
\r
893 "CIM_VendorPolicyAction.ActionData"} ]
\r
894 string ActionEncoding;
\r
898 // ==================================================================
\r
899 // CompoundPolicyAction
\r
900 // ==================================================================
\r
901 [Version ("2.6.0"),
\r
902 Description ("CompoundPolicyAction is used to represent an "
\r
903 "expression consisting of an ordered sequence of action "
\r
904 "terms. Each action term is represented as a subclass of "
\r
905 "the PolicyAction class. Compound actions are constructed "
\r
906 "by associating dependent action terms together using the "
\r
907 "PolicyActionInPolicyAction aggregation.") ]
\r
908 class CIM_CompoundPolicyAction : CIM_PolicyAction {
\r
910 "This property gives a policy administrator a way "
\r
911 "of specifying how the ordering of the PolicyActions "
\r
912 "associated with this PolicyRule is to be interpreted. "
\r
913 "Three values are supported: \n"
\r
914 " o mandatory(1): Do the actions in the indicated "
\r
915 " order, or don't do them at all. \n"
\r
916 " o recommended(2): Do the actions in the indicated "
\r
917 " order if you can, but if you can't do them in this "
\r
918 " order, do them in another order if you can. \n"
\r
919 " o dontCare(3): Do them -- I don't care about the "
\r
921 "The default value is 3 (\"DontCare\")."),
\r
922 ValueMap {"1", "2", "3"},
\r
923 Values {"Mandatory", "Recommended", "DontCare"} ]
\r
924 uint16 SequencedActions;
\r
925 [Description ("ExecutionStrategy defines the strategy to be "
\r
926 "used in executing the sequenced actions aggregated by this "
\r
927 "CompoundPolicyAction. There are three execution strategies: \n"
\r
929 "Do Until Success - execute actions according to predefined \n"
\r
930 " order, until successful execution of a \n"
\r
931 " single action. \n"
\r
932 "Do All - execute ALL actions which are part of \n"
\r
933 " the modeled set, according to their \n"
\r
934 " predefined order. Continue doing this, \n"
\r
935 " even if one or more of the actions "
\r
937 "Do Until Failure - execute actions according to predefined \n"
\r
938 " order, until the first failure in \n"
\r
939 " execution of an action instance. \n"
\r
940 "The default value is 2 (\"Do All\")."),
\r
941 ValueMap {"1", "2", "3"},
\r
942 Values {"Do Until Success", "Do All", "Do Until Failure"} ]
\r
943 uint16 ExecutionStrategy;
\r
947 // ==================================================================
\r
948 // === Association classes ===
\r
949 // ==================================================================
\r
952 // ==================================================================
\r
954 // ==================================================================
\r
955 [Association, Abstract, Aggregation, Version ("2.6.0"),
\r
957 "CIM_PolicyComponent is a generic association used to "
\r
958 "establish 'part of' relationships between the subclasses of "
\r
959 "CIM_Policy. For example, the PolicyConditionInPolicyRule "
\r
960 "association defines that PolicyConditions are part of a "
\r
962 class CIM_PolicyComponent {
\r
963 [Aggregate, Key, Description (
\r
964 "The parent Policy in the association.") ]
\r
965 CIM_Policy REF GroupComponent;
\r
966 [Key, Description (
\r
967 "The child/part Policy in the association.") ]
\r
968 CIM_Policy REF PartComponent;
\r
972 // ==================================================================
\r
974 // ==================================================================
\r
975 [Association, Abstract, Version ("2.6.0"), Description (
\r
976 "CIM_PolicyInSystem is a generic association used to "
\r
977 "establish dependency relationships between Policies and the "
\r
978 "Systems that host them. These Systems may be ComputerSystems "
\r
979 "where Policies are 'running' or they may be Policy"
\r
980 "Repositories where Policies are stored. This relationship "
\r
981 "is similar to the concept of CIM_Services being dependent "
\r
982 "on CIM_Systems as defined by the HostedService "
\r
985 "Cardinality is Max (1) for the Antecedent/System "
\r
986 "reference since Policies can only be hosted in at most one "
\r
987 "System context. Some subclasses of the association will "
\r
988 "further refine this definition to make the Policies Weak "
\r
989 "to Systems. Other subclasses of PolicyInSystem will "
\r
990 "define an optional hosting relationship. Examples of each "
\r
991 "of these are the PolicyRuleInSystem and PolicyConditionIn"
\r
992 "PolicyRepository associations, respectively.") ]
\r
993 class CIM_PolicyInSystem : CIM_Dependency {
\r
994 [Override ("Antecedent"), Max (1), Description (
\r
995 "The hosting System.") ]
\r
996 CIM_System REF Antecedent;
\r
997 [Override ("Dependent"), Description (
\r
998 "The hosted Policy.") ]
\r
999 CIM_Policy REF Dependent;
\r
1003 // ==================================================================
\r
1004 // PolicySetInSystem
\r
1005 // ==================================================================
\r
1006 [Association, Abstract, Version ("2.6.0"), Description (
\r
1007 "PolicySetInSystem is an abstract association class that "
\r
1008 "represents a relationship between a System and a PolicySet used "
\r
1009 "in the administrative scope of that system (e.g., AdminDomain, "
\r
1010 "ComputerSystem). The Priority property is used to assign a "
\r
1011 "relative priority to a PolicySet within the administrative "
\r
1012 "scope in contexts where it is not a component of another "
\r
1014 class CIM_PolicySetInSystem : CIM_PolicyInSystem {
\r
1015 [Override ("Antecedent"), Min (1), Max (1), Description (
\r
1016 "The System in whose scope a PolicySet is defined.") ]
\r
1017 CIM_System REF Antecedent;
\r
1018 [Override ("Dependent"), Description (
\r
1019 "A PolicySet named within the scope of a System.") ]
\r
1020 CIM_PolicySet REF Dependent;
\r
1022 "The Priority property is used to specify the relative "
\r
1023 "priority of the referenced PolicySet when there are more "
\r
1024 "than one PolicySet instances applied to a managed resource "
\r
1025 "that are not PolicySetComponents and, therefore, have no "
\r
1026 "other relative priority defined. The priority is a "
\r
1027 "non-negative integer; a larger value indicates a higher "
\r
1033 // ==================================================================
\r
1034 // PolicyGroupInSystem
\r
1035 // ==================================================================
\r
1036 [Association, Version ("2.6.0"), Description (
\r
1037 "An association that links a PolicyGroup to the System "
\r
1038 "in whose scope the Group is defined.") ]
\r
1039 class CIM_PolicyGroupInSystem : CIM_PolicySetInSystem {
\r
1040 [Override ("Antecedent"), Min (1), Max (1), Description (
\r
1041 "The System in whose scope a PolicyGroup is defined.") ]
\r
1042 CIM_System REF Antecedent;
\r
1043 [Override ("Dependent"), Weak, Description (
\r
1044 "A PolicyGroup named within the scope of a System.") ]
\r
1045 CIM_PolicyGroup REF Dependent;
\r
1049 // ==================================================================
\r
1050 // PolicyRuleInSystem
\r
1051 // ==================================================================
\r
1052 [Association, Version ("2.6.0"), Description (
\r
1053 "An association that links a PolicyRule to the System "
\r
1054 "in whose scope the Rule is defined.") ]
\r
1055 class CIM_PolicyRuleInSystem : CIM_PolicySetInSystem {
\r
1056 [Override ("Antecedent"), Min (1), Max (1), Description (
\r
1057 "The System in whose scope a PolicyRule is defined.") ]
\r
1058 CIM_System REF Antecedent;
\r
1059 [Override ("Dependent"), Weak, Description (
\r
1060 "A PolicyRule named within the scope of a System.") ]
\r
1061 CIM_PolicyRule REF Dependent;
\r
1065 // ==================================================================
\r
1066 // PolicySetComponent
\r
1067 // ==================================================================
\r
1068 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1069 "PolicySetComponent is a concrete aggregation class that "
\r
1070 "collects instances of PolicySet subclasses (PolicyGroups and "
\r
1071 "PolicyRules) into coherent sets of policies that have the same "
\r
1072 "decision strategy and are prioritized within the set.") ]
\r
1073 class CIM_PolicySetComponent : CIM_PolicyComponent {
\r
1074 [Override ("GroupComponent"), Aggregate, Description (
\r
1075 "A PolicySet that aggregates other PolicySet instances.") ]
\r
1076 CIM_PolicySet REF GroupComponent;
\r
1077 [Override ("PartComponent"), Description (
\r
1078 "A PolicySet aggregated into a PolicySet.") ]
\r
1079 CIM_PolicySet REF PartComponent;
\r
1081 "A non-negative integer for prioritizing this PolicySet"
\r
1082 "component relative to components of the same PolicySet. A "
\r
1083 "larger value indicates a higher priority.") ]
\r
1088 // ==================================================================
\r
1089 // PolicyGroupInPolicyGroup *** deprecated
\r
1090 // ==================================================================
\r
1091 [Association, Aggregation, DEPRECATED {"CIM_PolicySetComponent"},
\r
1092 Version ("2.6.0"), Description (
\r
1093 "PolicySetComponent provides a more general mechanism for "
\r
1094 "aggregating both PolicyGroups and PolicyRules and doing so with "
\r
1095 "the priority value applying only to the aggregated set rather "
\r
1096 "than policy wide. \n"
\r
1098 "A relationship that aggregates one or more lower-level "
\r
1099 "PolicyGroups into a higher-level Group. A Policy"
\r
1100 "Group may aggregate PolicyRules and/or other Policy"
\r
1102 class CIM_PolicyGroupInPolicyGroup : CIM_PolicyComponent {
\r
1103 [Override ("GroupComponent"), Aggregate, Description (
\r
1104 "A PolicyGroup that aggregates other Groups.") ]
\r
1105 CIM_PolicyGroup REF GroupComponent;
\r
1106 [Override ("PartComponent"), Description (
\r
1107 "A PolicyGroup aggregated by another Group.") ]
\r
1108 CIM_PolicyGroup REF PartComponent;
\r
1112 // ==================================================================
\r
1113 // PolicyRuleInPolicyGroup *** deprecated
\r
1114 // ==================================================================
\r
1115 [Association, Aggregation, DEPRECATED {"CIM_PolicySetComponent"},
\r
1116 Version ("2.6.0"), Description (
\r
1117 "PolicySetComponent provides a more general mechanism for "
\r
1118 "aggregating both PolicyGroups and PolicyRules and doing so with "
\r
1119 "the priority value applying only to the aggregated set rather "
\r
1120 "than policy wide. \n"
\r
1122 "A relationship that aggregates one or more PolicyRules "
\r
1123 "into a PolicyGroup. A PolicyGroup may aggregate "
\r
1124 "PolicyRules and/or other PolicyGroups.") ]
\r
1125 class CIM_PolicyRuleInPolicyGroup : CIM_PolicyComponent {
\r
1126 [Override ("GroupComponent"), Aggregate, Description (
\r
1127 "A PolicyGroup that aggregates one or more PolicyRules.") ]
\r
1128 CIM_PolicyGroup REF GroupComponent;
\r
1129 [Override ("PartComponent"), Description (
\r
1130 "A PolicyRule aggregated by a PolicyGroup.") ]
\r
1131 CIM_PolicyRule REF PartComponent;
\r
1135 // ==================================================================
\r
1136 // PolicyConditionInPolicyRule
\r
1137 // ==================================================================
\r
1138 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1139 "A PolicyRule aggregates zero or more instances of the "
\r
1140 "PolicyCondition class, via the PolicyConditionInPolicyRule "
\r
1141 "association. A Rule that aggregates zero Conditions is not "
\r
1142 "valid -- it may, however, be in the process of being entered "
\r
1143 "into a PolicyRepository or being defined for a System. Note "
\r
1144 "that a PolicyRule should have no effect until it is valid. \n"
\r
1146 "The Conditions aggregated by a PolicyRule are grouped into "
\r
1147 "two levels of lists: either an ORed set of ANDed sets of "
\r
1148 "conditions (DNF, the default) or an ANDed set of ORed sets "
\r
1149 "of conditions (CNF). Individual PolicyConditions in these "
\r
1150 "lists may be negated. The property ConditionListType "
\r
1151 "specifies which of these two grouping schemes applies to a "
\r
1152 "particular PolicyRule. \n"
\r
1154 "In either case, PolicyConditions are used to determine whether "
\r
1155 "to perform the PolicyActions associated with the PolicyRule. \n"
\r
1157 "One or more PolicyTimePeriodConditions may be among the "
\r
1158 "conditions associated with a PolicyRule via the Policy"
\r
1159 "ConditionInPolicyRule association. In this case, the time "
\r
1160 "periods are simply additional Conditions to be evaluated "
\r
1161 "along with any others that are specified for the Rule.") ]
\r
1162 class CIM_PolicyConditionInPolicyRule : CIM_PolicyComponent {
\r
1163 [Override ("GroupComponent"), Aggregate, Description (
\r
1164 "This property represents the PolicyRule that "
\r
1165 "contains one or more PolicyConditions.") ]
\r
1166 CIM_PolicyRule REF GroupComponent;
\r
1167 [Override ("PartComponent"), Description (
\r
1168 "This property holds the name of a PolicyCondition "
\r
1169 "contained by one or more PolicyRules.") ]
\r
1170 CIM_PolicyCondition REF PartComponent;
\r
1172 "Unsigned integer indicating the group to which the "
\r
1173 "PolicyCondition identified by the ContainedCondition "
\r
1174 "property belongs. This integer segments the Conditions "
\r
1175 "into the ANDed sets (when the ConditionListType is "
\r
1176 "\"DNF\") or similarly the ORed sets (when the Condition"
\r
1177 "ListType is \"CNF\") that are then evaluated.") ]
\r
1178 uint16 GroupNumber;
\r
1180 "Indication of whether the Condition identified by "
\r
1181 "the ContainedCondition property is negated. TRUE "
\r
1182 "indicates that the PolicyCondition IS negated, FALSE "
\r
1183 "indicates that it IS NOT negated.") ]
\r
1184 boolean ConditionNegated;
\r
1188 // ==================================================================
\r
1189 // PolicyRuleValidityPeriod
\r
1190 // ==================================================================
\r
1191 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1192 "The PolicyRuleValidityPeriod aggregation represents "
\r
1193 "scheduled activation and deactivation of a PolicyRule. "
\r
1194 "If a PolicyRule is associated with multiple policy time "
\r
1195 "periods via this association, then the Rule is active if "
\r
1196 "at least one of the time periods indicates that it is "
\r
1197 "active. (In other words, the PolicyTimePeriodConditions "
\r
1198 "are ORed to determine whether the Rule is active.) A Time"
\r
1199 "Period may be aggregated by multiple PolicyRules. A Rule "
\r
1200 "that does not point to a PolicyTimePeriodCondition via this "
\r
1201 "association is, from the point of view of scheduling, "
\r
1202 "always active. It may, however, be inactive for other "
\r
1203 "reasons. For example, the Rule's Enabled property may "
\r
1204 "be set to \"disabled\" (value=2).") ]
\r
1205 class CIM_PolicyRuleValidityPeriod : CIM_PolicyComponent {
\r
1206 [Override ("GroupComponent"), Aggregate, Description (
\r
1207 "This property contains the name of a PolicyRule that "
\r
1208 "contains one or more PolicyTimePeriodConditions.") ]
\r
1209 CIM_PolicyRule REF GroupComponent;
\r
1210 [Override ("PartComponent"), Description (
\r
1211 "This property contains the name of a "
\r
1212 "PolicyTimePeriodCondition defining the valid time periods "
\r
1213 "for one or more PolicyRules.") ]
\r
1214 CIM_PolicyTimePeriodCondition REF PartComponent;
\r
1218 // ==================================================================
\r
1219 // PolicyActionStructure
\r
1220 // ==================================================================
\r
1221 [Association, Aggregation, Abstract, Version ("2.6.0"),
\r
1223 "PolicyActions may be aggregated into rules and into "
\r
1224 "compound actions. PolicyActionStructure is the abstract "
\r
1225 "aggregation class for the structuring of policy actions.") ]
\r
1226 class CIM_PolicyActionStructure : CIM_PolicyComponent {
\r
1227 [Override ("GroupComponent"), Aggregate, Description (
\r
1228 "PolicyAction instances may be aggregated into either "
\r
1229 "PolicyRule instances or CompoundPolicyAction instances.") ]
\r
1230 CIM_Policy REF GroupComponent;
\r
1231 [Override ("PartComponent"), Description (
\r
1232 "A PolicyAction aggregated by a PolicyRule or "
\r
1233 "CompoundPolicyAction.") ]
\r
1234 CIM_PolicyAction REF PartComponent;
\r
1236 "ActionOrder is an unsigned integer 'n' that indicates the "
\r
1237 "relative position of a PolicyAction in the sequence of"
\r
1238 "actions associated with a PolicyRule or "
\r
1239 "CompoundPolicyAction. When 'n' is a positive integer, it "
\r
1240 "indicates a place in the sequence of actions to be "
\r
1241 "performed, with smaller integers indicating earlier "
\r
1242 "positions in the sequence. The special value '0' indicates "
\r
1243 "'don't care'. If two or more PolicyActions have the same "
\r
1244 "non-zero sequence number, they may be performed in any "
\r
1245 "order, but they must all be performed at the appropriate "
\r
1246 "place in the overall action sequence. \n"
\r
1248 "A series of examples will make ordering of PolicyActions "
\r
1250 " o If all actions have the same sequence number, \n"
\r
1251 " regardless of whether it is '0' or non-zero, any \n"
\r
1252 " order is acceptable. \n"
\r
1253 " o The values: \n"
\r
1258 " indicate two acceptable orders: A,C,B,D or C,A,B,D, \n"
\r
1259 " since A and C can be performed in either order, but \n"
\r
1260 " only at the '1' position. \n"
\r
1261 " o The values: \n"
\r
1266 " require that B,C, and D occur either as B,C,D or as \n"
\r
1267 " B,D,C. Action A may appear at any point relative to \n"
\r
1268 " B, C, and D. Thus the complete set of acceptable \n"
\r
1269 " orders is: A,B,C,D; B,A,C,D; B,C,A,D; B,C,D,A; \n"
\r
1270 " A,B,D,C; B,A,D,C; B,D,A,C; B,D,C,A. \n"
\r
1272 "Note that the non-zero sequence numbers need not start with "
\r
1273 "'1', and they need not be consecutive. All that matters is "
\r
1274 "their relative magnitude.") ]
\r
1275 uint16 ActionOrder;
\r
1279 // ==================================================================
\r
1280 // PolicyActionInPolicyRule
\r
1281 // ==================================================================
\r
1282 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1283 "A PolicyRule aggregates zero or more instances of the "
\r
1284 "PolicyAction class, via the PolicyActionInPolicyRule "
\r
1285 "association. A Rule that aggregates zero Actions is not "
\r
1286 "valid--it may, however, be in the process of being entered "
\r
1287 "into a PolicyRepository or being defined for a System. "
\r
1288 "Alternately, the actions of the policy may be explicit in "
\r
1289 "the definition of the PolicyRule. Note that a PolicyRule "
\r
1290 "should have no effect until it is valid. \n"
\r
1292 "The Actions associated with a PolicyRule may be given a "
\r
1293 "required order, a recommended order, or no order at all. "
\r
1294 "For Actions represented as separate objects, the "
\r
1295 "PolicyActionInPolicyRule aggregation can be used to express "
\r
1298 "This aggregation does not indicate whether a specified "
\r
1299 "action order is required, recommended, or of no "
\r
1300 "significance; the property SequencedActions in the "
\r
1301 "aggregating instance of PolicyRule provides this "
\r
1303 class CIM_PolicyActionInPolicyRule : CIM_PolicyActionStructure {
\r
1304 [Override ("GroupComponent"), Aggregate, Description (
\r
1305 "This property represents the PolicyRule that "
\r
1306 "contains one or more PolicyActions.") ]
\r
1307 CIM_PolicyRule REF GroupComponent;
\r
1308 [Override ("PartComponent"), Description (
\r
1309 "This property holds the name of a PolicyAction "
\r
1310 "contained by one or more PolicyRules.") ]
\r
1311 CIM_PolicyAction REF PartComponent;
\r
1315 // ==================================================================
\r
1316 // PolicyActionInPolicyAction
\r
1317 // ==================================================================
\r
1318 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1319 "PolicyActionInPolicyAction is used to represent the "
\r
1320 "compounding of policy actions into a higher-level policy "
\r
1322 class CIM_PolicyActionInPolicyAction : CIM_PolicyActionStructure {
\r
1323 [Override ("GroupComponent"), Aggregate, Description (
\r
1324 "This property represents the CompoundPolicyAction that "
\r
1325 "contains one or more PolicyActions.") ]
\r
1326 CIM_CompoundPolicyAction REF GroupComponent;
\r
1327 [Override ("PartComponent"), Description (
\r
1328 "This property holds the name of a PolicyAction "
\r
1329 "contained by one or more CompoundPolicyActions.") ]
\r
1330 CIM_PolicyAction REF PartComponent;
\r
1334 // ==================================================================
\r
1335 // PolicyContainerInPolicyContainer
\r
1336 // ==================================================================
\r
1337 [Association, Aggregation, Version ("2.6.0"), Description (
\r
1338 "A relationship that aggregates one or more lower-level "
\r
1339 "ReusablePolicyContainer instances into a higher-level "
\r
1340 "ReusablePolicyContainer.") ]
\r
1341 class CIM_PolicyContainerInPolicyContainer: CIM_SystemComponent {
\r
1342 [Override ("GroupComponent"), Aggregate, Description (
\r
1343 "A ReusablePolicyContainer that aggregates other "
\r
1344 "ReusablePolicyContainers.") ]
\r
1345 CIM_ReusablePolicyContainer REF GroupComponent;
\r
1346 [Override ("PartComponent"), Description (
\r
1347 "A ReusablePolicyContainer aggregated by another "
\r
1348 "ReusablePolicyContainer.") ]
\r
1349 CIM_ReusablePolicyContainer REF PartComponent;
\r
1353 // ==================================================================
\r
1354 // PolicyRepositoryInPolicyRepository *** deprecated
\r
1355 // ==================================================================
\r
1356 [Association, Aggregation,
\r
1357 DEPRECATED {"CIM_PolicyContainerInPolicyContainer"},
\r
1358 Version ("2.6.0"), Description (
\r
1359 "The term 'PolicyRepository' has been confusing to both "
\r
1360 "developers and users of the model. The replacement class "
\r
1361 "name describes model element properly and is less likely "
\r
1362 "to be confused with a data repository. ContainedDomain is a "
\r
1363 "general purpose mechanism for expressing domain hierarchy. \n"
\r
1365 "A relationship that aggregates one or more lower-level "
\r
1366 "PolicyRepositories into a higher-level Repository.") ]
\r
1367 class CIM_PolicyRepositoryInPolicyRepository : CIM_SystemComponent {
\r
1368 [Override ("GroupComponent"), Aggregate, Description (
\r
1369 "A PolicyRepository that aggregates other Repositories.") ]
\r
1370 CIM_PolicyRepository REF GroupComponent;
\r
1371 [Override ("PartComponent"), Description (
\r
1372 "A PolicyRepository aggregated by another Repository.") ]
\r
1373 CIM_PolicyRepository REF PartComponent;
\r
1377 // ==================================================================
\r
1379 // ==================================================================
\r
1380 [Association, Version ("2.6.0"), Description (
\r
1381 "The ReusablePolicy association provides for the reuse of any "
\r
1382 "subclass of Policy in a ReusablePolicyContainer.") ]
\r
1383 class CIM_ReusablePolicy : CIM_PolicyInSystem {
\r
1384 [Override ("Antecedent"), Max (1), Description (
\r
1385 "This property identifies a ReusablePolicyContainer that "
\r
1386 "provides the administrative scope for the reuse of the "
\r
1387 "referenced policy element.") ]
\r
1388 CIM_ReusablePolicyContainer REF Antecedent;
\r
1389 [Override ("Dependent"), Description (
\r
1390 "A reusable policy element.") ]
\r
1391 CIM_Policy REF Dependent;
\r
1395 // ==================================================================
\r
1396 // PolicyConditionInPolicyRepository *** deprecated
\r
1397 // ==================================================================
\r
1398 [Association, DEPRECATED {"CIM_ReusablePolicy"},
\r
1399 Version ("2.6.0"), Description (
\r
1400 "The ReusablePolicy association is a more general relationship "
\r
1401 "that incorporates both Conditions and Actions as well as any "
\r
1402 "other policy subclass. \n"
\r
1404 "A class representing the hosting of reusable "
\r
1405 "PolicyConditions by a PolicyRepository. A reusable Policy"
\r
1406 "Condition is always related to a single PolicyRepository, "
\r
1407 "via this association. \n"
\r
1409 "Note, that an instance of PolicyCondition can be either "
\r
1410 "reusable or rule-specific. When the Condition is rule-"
\r
1411 "specific, it shall not be related to any "
\r
1412 "PolicyRepository via the PolicyConditionInPolicyRepository "
\r
1414 class CIM_PolicyConditionInPolicyRepository : CIM_PolicyInSystem {
\r
1415 [Override ("Antecedent"), Max (1), Description (
\r
1416 "This property identifies a PolicyRepository "
\r
1417 "hosting one or more PolicyConditions. A reusable "
\r
1418 "PolicyCondition is always related to exactly one "
\r
1419 "PolicyRepository via the PolicyConditionInPolicyRepository "
\r
1420 "association. The [0..1] cardinality for this property "
\r
1421 "covers the two types of PolicyConditions: 0 for a "
\r
1422 "rule-specific PolicyCondition, 1 for a reusable one.") ]
\r
1423 CIM_PolicyRepository REF Antecedent;
\r
1424 [Override ("Dependent"), Description (
\r
1425 "This property holds the name of a PolicyCondition"
\r
1426 "hosted in the PolicyRepository.") ]
\r
1427 CIM_PolicyCondition REF Dependent;
\r
1431 // ==================================================================
\r
1432 // PolicyActionInPolicyRepository *** deprecated
\r
1433 // ==================================================================
\r
1434 [Association, DEPRECATED {"CIM_ReusablePolicy"},
\r
1435 Version ("2.6.0"), Description (
\r
1436 "The ReusablePolicy association is a more general relationship "
\r
1437 "that incorporates both Conditions and Actions as well as any "
\r
1438 "other policy subclass. \n"
\r
1440 "A class representing the hosting of reusable "
\r
1441 "PolicyActions by a PolicyRepository. A reusable Policy"
\r
1442 "Action is always related to a single PolicyRepository, "
\r
1443 "via this association. \n"
\r
1445 "Note, that an instance of PolicyAction can be either "
\r
1446 "reusable or rule-specific. When the Action is rule-"
\r
1447 "specific, it shall not be related to any "
\r
1448 "PolicyRepository via the PolicyActionInPolicyRepository "
\r
1450 class CIM_PolicyActionInPolicyRepository : CIM_PolicyInSystem {
\r
1451 [Override ("Antecedent"), Max (1), Description (
\r
1452 "This property represents a PolicyRepository "
\r
1453 "hosting one or more PolicyActions. A reusable "
\r
1454 "PolicyAction is always related to exactly one "
\r
1455 "PolicyRepository via the PolicyActionInPolicyRepository "
\r
1456 "association. The [0..1] cardinality for this property "
\r
1457 "covers the two types of PolicyActions: 0 for a "
\r
1458 "rule-specific PolicyAction, 1 for a reusable one.") ]
\r
1459 CIM_PolicyRepository REF Antecedent;
\r
1460 [Override ("Dependent"), Description (
\r
1461 "This property holds the name of a PolicyAction"
\r
1462 "hosted in the PolicyRepository.") ]
\r
1463 CIM_PolicyAction REF Dependent;
\r
1467 // ===================================================================
\r
1469 // ===================================================================
\r
git.samba.org / tpot / pegasus / .git / blob