view Side-By-Side changes
Policy Framework Working Group B. Moore
INTERNET-DRAFT E. Ellesson
Category: Standards Track IBM
J. Strassner
A. Westerinen
Cisco Systems
July,
October, 2000
Policy Core Information Model -- Version 1 Specification
<draft-ietf-policy-core-info-model-07.txt>
<draft-ietf-policy-core-info-model-08.txt>
Friday, July 14, October 13, 2000, 1:33 PM 9:19 AM
Status of this Memo
This document is an Internet-Draft and is in full conformance with all
provisions of Section 10 of RFC2026.
Internet-Drafts are working documents of the Internet Engineering Task
Force (IETF), its areas, and its working groups. Note that other groups
may also distribute working documents as Internet-Drafts.
Internet-Drafts are draft documents valid for a maximum of six months and
may be updated, replaced, or obsoleted by other documents at any time.
It is inappropriate to use Internet-Drafts as reference material or to
cite them other than as "work in progress."
The list of current Internet-Drafts can be accessed at
http://www.ietf.org/ietf/1id-abstracts.txt
The list of Internet-Draft Shadow Directories can be accessed at
http://www.ietf.org/shadow.html
Copyright Notice
Copyright (C) The Internet Society (2000). All Rights Reserved.
Abstract
This document presents the object-oriented information model for
representing policy information developed jointly in the IETF Policy
Framework WG and as extensions to the Common Information Model (CIM)
activity in the Distributed Management Task Force (DMTF). This model
defines two hierarchies of object classes: structural classes
representing policy information and control of policies, and association
classes that indicate how instances of the structural classes are related
to each other. Subsequent documents will define mappings of this
information model to various concrete implementations, for example, to a
directory that uses LDAPv3 as its access protocol. The components of the
CIM schema are available via the following URL:
http://www.dmtf.org/spec/cims.html [1].
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 1]
Internet Draft Policy Core Information Model July October 2000
Table of Contents
1. Introduction......................................................4
2. Modeling Policies.................................................5
2.1. Policy Scope.................................................7
2.2. Declarative versus Procedural Model..........................8 Model..........................7
3. Overview of the Policy Core Information Model.....................9
4. Inheritance Hierarchies for the Policy Core Information Model....12
4.1. Implications of CIM Inheritance.............................13
5. Details of the Model.............................................13 Model.............................................14
5.1. Reusable versus Rule-Specific Conditions and Actions........13 Actions........14
5.2. Roles.......................................................15
5.2.1. Roles and Role Combinations...............................15
5.2.2. The PolicyRoles Property..................................18 Property..................................19
5.3. Local Time and UTC Time in PolicyTimePeriodConditions.......18 PolicyTimePeriodConditions.......19
5.4. CIM Data Types..............................................20 Types..............................................21
5.5. Comparison between CIM and LDAP Class Specifications........22
6. Class Definitions................................................20 Definitions................................................23
6.1. The Abstract Class "Policy".................................21 "Policy".................................23
6.1.1. The Property "CommonName (CN)"............................22 (CN)"............................23
6.1.2. The Multi-valued Property "PolicyKeywords"................22 "PolicyKeywords"................23
6.1.3. The Property "Caption" (Inherited from ManagedElement)....23 ManagedElement)....24
6.1.4. The Property "Description" (Inherited from ManagedElement)23 ManagedElement)24
6.2. The Class "PolicyGroup".....................................23 "PolicyGroup".....................................25
6.3. The Class "PolicyRule"......................................24 "PolicyRule"......................................26
6.3.1. The Property "Enabled"....................................26 "Enabled"....................................28
6.3.2. The Property "ConditionListType"..........................26 "ConditionListType"..........................28
6.3.3. The Property "RuleUsage"..................................27 "RuleUsage"..................................28
6.3.4. The Property "Priority"...................................27 "Priority"...................................29
6.3.5. The Property "Mandatory"..................................27 "Mandatory"..................................29
6.3.6. The Property "SequencedActions"...........................28 "SequencedActions"...........................29
6.3.7. The Multi-valued Property "PolicyRoles"...................28 "PolicyRoles"...................30
6.4. The Abstract Class "PolicyCondition".................................29 "PolicyCondition"........................30
6.5. The Class "PolicyTimePeriodCondition".......................31 "PolicyTimePeriodCondition".......................33
6.5.1. The Property "TimePeriod".................................32 "TimePeriod".................................34
6.5.2. The Property "MonthOfYearMask"............................33 "MonthOfYearMask"............................35
6.5.3. The Property "DayOfMonthMask".............................34 "DayOfMonthMask".............................36
6.5.4. The Property "DayOfWeekMask"..............................35 "DayOfWeekMask"..............................37
6.5.5. The Property "TimeOfDayMask"..............................35 "TimeOfDayMask"..............................37
6.5.6. The Property "LocalOrUtcTime".............................36 "LocalOrUtcTime".............................38
6.6. The Class "VendorPolicyCondition"...........................36 "VendorPolicyCondition"...........................38
6.6.1. The Multi-valued Property "Constraint"....................37 "Constraint"....................39
6.6.2. The Property "ConstraintEncoding".........................38 "ConstraintEncoding".........................39
6.7. The Abstract Class "PolicyAction"....................................38 "PolicyAction"...........................40
6.8. The Class "VendorPolicyAction"..............................39 "VendorPolicyAction"..............................41
6.8.1. The Multi-valued Property "ActionData"....................39 "ActionData"....................41
6.8.2. The Property "ActionEncoding".............................40 "ActionEncoding".............................42
6.9. The Class "PolicyRepository"................................40 "PolicyRepository"................................42
7. Association and Aggregation Definitions..........................41 Definitions..........................42
7.1. Associations................................................41 Associations................................................42
7.2. Aggregations................................................41 Aggregations................................................43
7.3. The Abstract Aggregation "PolicyComponent...................41
7.4. The Aggregation "PolicyGroupInPolicyGroup"..................41
7.4.1. The Reference "GroupComponent"............................42
7.4.2. The Reference "PartComponent".............................42 "PolicyComponent...................43
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 2]
Internet Draft Policy Core Information Model July October 2000
7.4. The Aggregation "PolicyGroupInPolicyGroup"..................43
7.4.1. The Reference "GroupComponent"............................44
7.4.2. The Reference "PartComponent".............................44
7.5. The Aggregation "PolicyRuleInPolicyGroup"...................42 "PolicyRuleInPolicyGroup"...................44
7.5.1. The Reference "GroupComponent"............................43 "GroupComponent"............................44
7.5.2. The Reference "PartComponent".............................43 "PartComponent".............................45
7.6. The Aggregation "PolicyConditionInPolicyRule"...............43 "PolicyConditionInPolicyRule"...............45
7.6.1. The Reference "GroupComponent"............................44 "GroupComponent"............................46
7.6.2. The Reference "PartComponent".............................44 "PartComponent".............................46
7.6.3. The Property "GroupNumber"................................44 "GroupNumber"................................46
7.6.4. The Property "ConditionNegated"...........................44 "ConditionNegated"...........................46
7.7. The Aggregation "PolicyRuleValidityPeriod"..................45 "PolicyRuleValidityPeriod"..................47
7.7.1. The Reference "GroupComponent"............................45 "GroupComponent"............................47
7.7.2. The Reference "PartComponent".............................45 "PartComponent".............................47
7.8. The Aggregation "PolicyActionInPolicyRule"..................46 "PolicyActionInPolicyRule"..................48
7.8.1. The Reference "GroupComponent"............................46 "GroupComponent"............................48
7.8.2. The Reference "PartComponent".............................46 "PartComponent".............................48
7.8.3. The Property "ActionOrder"................................47 "ActionOrder"................................49
7.9. The Abstract Association "PolicyInSystem"...................48 "PolicyInSystem"...................50
7.10. The Weak Association "PolicyGroupInSystem".................48 "PolicyGroupInSystem".................50
7.10.1. The Reference "Antecedent"...............................48 "Antecedent"...............................50
7.10.2. The Reference "Dependent"................................49 "Dependent"................................51
7.11. The Weak Association "PolicyRuleInSystem"..................49 "PolicyRuleInSystem"..................51
7.11.1. The Reference "Antecedent"...............................49 "Antecedent"...............................51
7.11.2. The Reference "Dependent"................................49 "Dependent"................................51
7.12. The Association "PolicyConditionInPolicyRepository"........49 "PolicyConditionInPolicyRepository"........51
7.12.1. The Reference "Antecedent"...............................50 "Antecedent"...............................52
7.12.2. The Reference "Dependent"................................50 "Dependent"................................52
7.13. The Association "PolicyActionInPolicyRepository"...........50 "PolicyActionInPolicyRepository"...........52
7.13.1. The Reference "Antecedent"...............................50 "Antecedent"...............................52
7.13.2. The Reference "Dependent"................................51 "Dependent"................................53
7.14. The Aggregation "PolicyRepositoryInPolicyRepository".......51 "PolicyRepositoryInPolicyRepository".......53
7.14.1. The Reference "GroupComponent"...........................51 "GroupComponent"...........................53
7.14.2. The Reference "PartComponent"............................51 "PartComponent"............................53
8. Intellectual Property............................................52 Property............................................54
9. Acknowledgements.................................................52 Acknowledgements.................................................54
10. Security Considerations.........................................52 Considerations.........................................54
11. References......................................................54 References......................................................56
12. Authors' Addresses..............................................55 Addresses..............................................57
13. Full Copyright Statement........................................56 Statement........................................58
14. Appendix A - A: Class Identification in a Native CIM Implementation57 Implementation59
14.1. Naming Instances of PolicyGroup and PolicyRule.............57 PolicyRule.............59
14.1.1. PolicyGroup's CIM Keys...................................57 Keys...................................59
14.1.2. PolicyRule's CIM Keys....................................58 Keys....................................60
14.2. Naming Instances of PolicyCondition and Its Subclasses.....59 Subclasses.....61
14.2.1. PolicyCondition's CIM Keys...............................61 Keys...............................63
14.3. Naming Instances of PolicyAction and Its Subclasses........62 Subclasses........64
14.4. Naming Instances of PolicyRepository.......................64 PolicyRepository.......................66
14.5. Role of the CreationClassName Property in Naming...........64 Naming...........66
14.6. Object References..........................................65 References..........................................67
15. Appendix B: The Core Policy MOF................................68
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 3]
Internet Draft Policy Core Information Model July October 2000
1. Introduction
This document presents the object-oriented information model for
representing policy information currently under joint development in the
IETF Policy Framework WG and as extensions to the Common Information
Model (CIM) activity in the Distributed Management Task Force (DMTF).
This model defines two hierarchies of object classes: structural classes
representing policy information and control of policies, and association
classes that indicate how instances of the structural classes are related
to each other. Subsequent documents will define mappings of this
information model to various concrete implementations, for example, to a
directory that uses LDAPv3 as its access protocol.
The policy classes and associations defined in this model are
sufficiently generic to allow them to represent policies related to
anything. However, it is expected that their initial application in the
IETF will be for representing policies related to QoS (DiffServ and
IntServ) and to IPSec. Policy models for application-specific areas such
as these may extend the Core Model in several ways. The preferred way is
to use the PolicyGroup, PolicyRule, and PolicyTimePeriodCondition classes
directly, as a foundation for representing and communicating policy
information. Then, specific subclasses derived from PolicyCondition and
PolicyAction can capture application-specific definitions of conditions
and actions of policies.
Two subclasses, VendorPolicyCondition and VendorPolicyAction, are also
included in this document, to provide a standard extension mechanism for
vendor-specific extensions to the Policy Core Information Model.
This document fits into the overall framework for representing,
deploying, and managing policies being developed by the Policy Framework
Working Group. It traces its origins to work that was originally done
for the Directory-enabled Networks (DEN) specification, reference [5].
Work on the DEN specification by the DEN Ad-Hoc Working Group itself has
been completed. Further work to standardize the models contained in it
will be the responsibility of selected working groups of the CIM effort
in the Distributed Management Task Force (DMTF). DMTF standardization of
the core policy model is the responsibility of the SLA Policy working
group in the DMTF.
This document is organized in the following manner:
o Section 2 provides a general overview of policies and how they are
modeled.
o Section 3 presents a high-level overview of the classes and
associations comprising the Policy Core Information Model.
o The remainder of the document presents the detailed specifications for
each of the classes and associations.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 4]
Internet Draft Policy Core Information Model July October 2000
o Appendix A overviews naming for native CIM implementations. Other
mappings, such as LDAPv3, will have their own naming mechanisms.
o Appendix B reproduces the DMTF's Core Policy MOF specification.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119, reference [3].
2. Modeling Policies
The classes comprising the Policy Core Information Model are intended to
serve as an extensible class hierarchy (through specialization) for
defining policy objects that enable application developers, network
administrators, and policy administrators to represent policies of
different types.
One way to think of a policy-controlled network is to first model the
network as a state machine and then use policy to control which state a
policy-controlled device should be in or is allowed to be in at any given
time. Given this approach, policy is applied using a set of policy
rules. Each policy rule consists of a set of conditions and a set of
actions. Policy rules may be aggregated into policy groups. These
groups may be nested, to represent a hierarchy of policies.
The set of conditions associated with a policy rule specifies when the
policy rule is applicable. The set of conditions can be expressed as
either an ORed set of ANDed sets of condition statements or an ANDed set
of ORed sets of statements. Individual condition statements can also be
negated. These combinations are termed, respectively, Disjunctive Normal
Form (DNF) and Conjunctive Normal Form (CNF) for the conditions.
If the set of conditions associated with a policy rule evaluates to TRUE,
then a set of actions that either maintain the current state of the
object or transition the object to a new state may be executed. For the
set of actions associated with a policy rule, it is possible to specify
an order of execution, as well as an indication of whether the order is
required or merely recommended. It is also possible to indicate that the
order in which the actions are executed does not matter.
Policy rules themselves can be prioritized. One common reason for doing
this is to express an overall policy that has a general case with a few
specific exceptions.
For example, a general QoS policy rule might specify that traffic
originating from members of the engineering group is to get Bronze
Service. A second policy rule might express an exception: traffic
originating from John, a specific member of the engineering group, is to
get Gold Service. Since traffic originating from John satisfies the
conditions of both policy rules, and since the actions associated with
the two rules are incompatible, a priority needs to be established. By
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 5]
Internet Draft Policy Core Information Model July October 2000
established. By
giving the second rule (the exception) a higher priority than the first
rule (the general case), a policy administrator can get the desired
effect: traffic originating from John gets Gold Service, and traffic
originating from all the other members of the engineering group gets
Bronze Service.
Policies can either be used in a stand-alone fashion or aggregated into
policy groups to perform more elaborate functions. Stand-alone policies
are called policy rules. Policy groups are aggregations of policy rules,
or aggregations of policy groups, but not both. Policy groups can model
intricate interactions between objects that have complex
interdependencies. Examples of this include a sophisticated user logon
policy that sets up application access, security, and reconfigures
network connections based on a combination of user identity, network
location, logon method and time of day. A policy group represents a unit
of reusability and manageability in that its management is handled by an
identifiable group of administrators and its policy rules would be
consistently applied
Stand-alone policies are those that can be expressed in a simple
statement. They can be represented effectively in schemata or MIBs.
Examples of this are VLAN assignments, simple YES/NO QoS requests, and IP
address allocations. A specific design goal of this model is to support
both stand-alone and aggregated policies.
Policy groups and rules can be classified by their purpose and intent.
This classification is useful in querying or grouping policy rules. It
indicates whether the policy is used to motivate when or how an action
occurs, or to characterize services (that can then be used, for example,
to bind clients to network services). Describing each of these concepts
in more detail,
o Motivational Policies are solely targeted at whether or how a policy's
goal is accomplished. Configuration and Usage Policies are specific
kinds of Motivational Policies. Another example is the scheduling of
file backup based on disk write activity from 8am to 3pm, M-F.
o Configuration Policies define the default (or generic) setup of a
managed entity (for example, a network service). Examples of
Configuration Policies are the setup of a network forwarding service
or a network-hosted print queue.
o Installation Policies define what can and cannot be put on a system or
component, as well as the configuration of the mechanisms that perform
the install. Installation policies typically represent specific
administrative permissions, and can also represent dependencies
between different components (e.g., to complete the installation of
component A, components B and C must be previously successfully
installed or uninstalled).
Moore, et al. Expires: Jul 2000 + 6 months [Page 6]
Internet Draft Policy Core Information Model July 2000
o Error and Event Policies. For example, if a device fails between 8am
and 9pm, call the system administrator, otherwise call the Help Desk.
Moore, et al. Expires: Oct 2000 + 6 months [Page 6]
Internet Draft Policy Core Information Model October 2000
o Usage Policies control the selection and configuration of entities
based on specific "usage" data. Configuration Policies can be
modified or simply re-applied by Usage Policies. Examples of Usage
Policies include upgrading network forwarding services after a user is
verified to be a member of a "gold" service group, or reconfiguring a
printer to be able to handle the next job in its queue.
o Security Policies deal with verifying that the client is actually who
the client purports to be, permitting or denying access to resources,
selecting and applying appropriate authentication mechanisms, and
performing accounting and auditing of resources.
o Service Policies characterize network and other services (not use
them). For example, all wide-area backbone interfaces shall use a
specific type of queuing.
Service policies describe services available in the network. Usage
policies describe the particular binding of a client of the network to
services available in the network.
These categories are represented in the Policy Core Information Model by
special values defined for the PolicyKeywords property of the abstract
class Policy.
2.1. Policy Scope
Policies represent business goals and objectives. A translation must be
made between these goals and objectives and their realization in the
network. An example of this could be a Service Level Agreement (SLA), and
its objectives and metrics (Service Level Objectives, or SLOs), that are
used to specify services that the network will provide for a given
client. The SLA will usually be written in high-level business
terminology. SLOs address more specific metrics in support of the SLA.
These high-level descriptions of network services and metrics must be
translated into lower-level, but also vendor- and device-
independent device-independent
specifications. The Policy Core Information Model classes are intended to
serve as the foundation for these lower-level, vendor- and device-independent device-
independent specifications.
It is envisioned that the definition of the Policy Core Informational
Model in this draft is generic in nature and is applicable to Quality of
Service (QoS), to non-QoS networking applications (e.g., DHCP and IPSec),
and to non-networking applications (e.g., backup policies, auditing
access, etc.).
Moore, et al. Expires: Jul 2000 + 6 months [Page 7]
Internet Draft Policy Core Information Model July 2000
2.2. Declarative versus Procedural Model
The design of the Policy Core Information Model is influenced by a
declarative, not procedural, approach. More formally, a declarative
language is used to describe relational and functional languages.
Declarative languages describe relationships between variables in terms
of functions or inference rules, to which the interpreter or compiler can
Moore, et al. Expires: Oct 2000 + 6 months [Page 7]
Internet Draft Policy Core Information Model October 2000
apply a fixed algorithm in order to produce a result. An imperative (or
procedural) language specifies an explicit sequence of steps to follow in
order to produce a result.
It is important to note that this information model does not rule out the
use of procedural languages. Rather, it recognizes that both declarative
as well as procedural languages can be used to implement policy. This
information model is better viewed as being declarative because the
sequence of steps for doing the processing of declarative statements
tends to be left to the implementer. However, we have provided the option
of expressing the desired order of action execution in this policy
information model, and for expressing whether the order is mandatory or
not. In addition, rather than trying to define algorithms or sets of
instructions or steps that must be followed by a policy rule, we instead
define a set of modular building blocks and relationships that can be
used in a declarative or procedural fashion to define policies.
Compare this to a strictly procedural model. Taking such an approach
would require that we specify the condition testing sequence, and the
action execution sequence, in the policy repository itself. This would,
indeed, constrain the implementer. This is why the policy model is
characterized as a declarative one. That is, the information model
defines a set of attributes, and a set of entities that contain these
attributes. However, it does NOT define either the algorithm to produce a
result using the attributes or an explicit sequence of steps to produce a
result.
There are several design considerations and trade-offs to make in this
respect.
1. On the one hand, we would like a policy definition language to be
reasonably human-friendly for ease of definitions and diagnostics. On
the other hand, given the diversity of devices (in terms of their
processing capabilities) which could act as policy decision points, we
would like to keep the language somewhat machine-
friendly. machine-friendly. That is, it
should be relatively simple to automate the parsing and processing of
the language in network elements. The approach taken is to provide a
set of classes and attributes that can be combined in either a
declarative or procedural approach to express policies that manage
network elements and services. The key point is to avoid trying to
standardize rules or sets of steps to be followed in defining a
policy. These must be left up to an implementation. Interoperability
is achieved by standardizing the building blocks that are used to
represent policy data and information.
Moore, et al. Expires: Jul 2000 + 6 months [Page 8]
Internet Draft Policy Core Information Model July 2000
2. An important decision to make is the semantic style of the
representation of the information.
The declarative approach that we are describing falls short of being a
"true" declarative model. Such a model would also specify the
algorithms used to combine the information and policy rules to achieve
particular behavior. We avoid specifying algorithms for the same
Moore, et al. Expires: Oct 2000 + 6 months [Page 8]
Internet Draft Policy Core Information Model October 2000
reason that we avoid specifying sets of steps to be followed in a
policy rule. However, the design of the information model more closely
follows that of a declarative language, and may be easier to
understand if such a conceptual model is used. This leads to our third
point, acknowledging a lack of "completeness" and instead relying on
presenting information that the policy processing entity will work
with.
3. It is important to control the complexity of the specification,
trading off richness of expression of data in the core information
model for ease of implementation and use. It is important to
acknowledge the collective lack of experience in the field regarding
policies to control and manage network services and
hence avoid the temptation of aiming for "completeness". We should
instead strive to facilitate definition of a set of common policies
that customers require today (e.g., VPN and QoS) and allow migration
paths towards supporting complex policies as customer needs and our
understanding of these policies evolve with experience. Specifically,
in the context of the declarative style language discussed above, it
is important to avoid having full blown predicate calculus as the
language, as it would render many important problems such as
consistency checking and policy decision point algorithms intractable.
It is useful to consider a reasonably constrained language from these
perspectives.
The Policy Core Information Model strikes a balance between complexity
and lack of power by using the well understood logical concepts of
Disjunctive Normal Form and Conjunctive Normal Form for combining simple
policy conditions into more complex ones.
3. Overview of the Policy Core Information Model
The following diagram provides an overview of the five central classes
comprising the Policy Core Information Model, their associations to each
other, and their associations to other classes in the overall CIM model.
Note that the abstract class Policy and the two extension classes
VendorPolicyCondition and VendorPolicyAction are not shown.
NOTE: For cardinalities, "*" is an abbreviation for "0..n".
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 9]
Internet Draft Policy Core Information Model July October 2000
+-----------+
| System |
..... +--^-----^--+ .....
. . 1. 1. . .
*.(a).* .(b) .(c) *.(d).*
+--v---v---------+ . . +-v---v------------+
| PolicyGroup <........ . | PolicyRepository |
| | w * . | |
+------^---------+ . +-----^---------^--+
*. . 0..1 . 0..1 .
.(e) . .(f) .(g)
*. . . .
+------v------+ w * . . .
| <................. . .
| PolicyRule | . .
| | . .
| | . .
| <........................ . .
| |* (h) . . .
| | . . .
| | . . .
| | . . .
| | . . .
| | . . .
| | . . .
| | .* .* .
| | +---------v-------v--+ .
| | | PolicyCondition | .
| | *+--------------------+ .
| | (i) ^ .
| <.............. I .
| |* . I .
| | .* ^ .
| | +----v----------------------+ .
| | | PolicyTimePeriodCondition | .
| | +---------------------------+ .
| | (j) .
| <......................... .
| |* . .
| | .* .
| | +----------v---------+* .
| | | PolicyAction <.......
+-------------+ +--------------------+
Figure 1. Overview of the Core Policy Classes and Relationships
In this figure the boxes represent the classes, and the dotted arrows
represent the associations. The following associations appear:
(a) PolicyGroupInPolicyGroup
(b) PolicyGroupInSystem
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 10]
Internet Draft Policy Core Information Model July October 2000
(c) PolicyRuleInSystem
(d) PolicyRepositoryInPolicyRepository
(e) PolicyRuleInPolicyGroup
(f) PolicyConditionInPolicyRepository
(g) PolicyActionInPolicyRepository
(h) PolicyConditionInPolicyRule
(i) PolicyRuleValidityPeriod
(j) PolicyActionInPolicyRule
An association always connects two classes. The "two" classes may,
however, be the same class, as is the case with the
PolicyGroupInPolicyGroup association, which represents the recursive
containment of PolicyGroups in other PolicyGroups. The
PolicyRepositoryInPolicyRepository association is recursive in the same
way.
An association includes cardinalities for each of the related classes.
These cardinalities indicate how many instances of each class may be
related to an instance of the other class. For example, the
PolicyRuleInPolicyGroup association has the cardinality range "*' (that
is, "0..n") for both the PolicyGroup and PolicyRule classes. These
ranges are interpreted as follows:
o The "*" written next to PolicyGroup indicates that a PolicyRule may be
related to no PolicyGroups, to one PolicyGroup, or to more than one
PolicyGroup via the PolicyGroupInPolicyGroup PolicyRuleInPolicyGroup association. In other
words, a PolicyRule may be contained in no PolicyGroups, in one
PolicyGroups, or in more than one PolicyGroup.
o The "*" written next to PolicyRule indicates that a PolicyGroup may be
related to no PolicyRules, to one PolicyRule, or to more than one
PolicyRule via the PolicyGroupInPolicyGroup PolicyRuleInPolicyGroup association. In other
words, a PolicyGroup may contain no PolicyRules, one PolicyRule, or
more than one PolicyRule.
The "w" written next to the PolicyGroupInSystem and PolicyRuleInSystem
indicates that these are what CIM terms "aggregations with weak
references", or more briefly, "weak aggregations." A weak aggregation
is simply an indication of a naming scope. Thus these two aggregations
indicate that an instance of a PolicyGroup or PolicyRule is named within
the scope of a System object. A weak aggregation implicitly has the
cardinality 1..1 at the end opposite the 'w'.
The associations shown in Figure 1 are discussed in more detail in
Section 7.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 11]
Internet Draft Policy Core Information Model July October 2000
4. Inheritance Hierarchies for the Policy Core Information Model
The following diagram illustrates the inheritance hierarchy for the core
policy classes:
ManagedElement (abstract)
|
+--Policy (abstract)
| |
| +---PolicyGroup
| |
| +---PolicyRule
| |
| +---PolicyCondition (abstract)
| | |
| | +---PolicyTimePeriodCondition
| | |
| | +---VendorPolicyCondition
| |
| +---PolicyAction (abstract)
| |
| +---VendorPolicyAction
|
+--ManagedSystemElement (abstract)
|
+--LogicalElement (abstract)
|
+--System (abstract)
|
+--AdminDomain (abstract)
|
+---PolicyRepository
Figure 2. Inheritance Hierarchy for the Core Policy Classes
ManagedElement, as well as the four additional CIM classes from which
PolicyRepository is derived, ManagedSystemElement, LogicalElement, System, and
AdminDomain are defined in the CIM schema [1]. These classes are not
discussed in detail in this document.
In CIM, associations are also modeled as classes. For the Policy Core
Information Model, the inheritance hierarchy for the associations is as
follows:
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 12]
Internet Draft Policy Core Information Model July October 2000
[unrooted]
|
+---PolicyComponent (abstract)
| |
| +---PolicyGroupInPolicyGroup
| |
| +---PolicyRuleInPolicyGroup
| |
| +---PolicyConditionInPolicyRule
| |
| +---PolicyRuleValidityPeriod
| |
| +---PolicyActionInPolicyRule
|
+---Dependency (abstract)
| |
| +---PolicyInSystem (abstract)
| |
| +---PolicyGroupInSystem
| |
| +---PolicyRuleInSystem
| |
| +---PolicyConditionInPolicyRepository
| |
| +---PolicyActionInPolicyRepository
|
+---Component (abstract)
|
+---SystemComponent
|
+---PolicyRepositoryInPolicyRepository
Figure 3. Inheritance Hierarchy for the Core Policy Associations
5. Details of the Model
The following subsections discuss several specific issues related to
the Policy Core Information Model.
5.1. Reusable versus Rule-Specific Conditions Dependency, Component, and Actions
Policy conditions SystemComponent associations are defined
in the CIM schema [1], and policy actions can be partitioned into two
groups: ones associated with a single policy rule, and ones that are
reusable, not discussed further in this document.
4.1. Implications of CIM Inheritance
From the sense that they may be associated with more than one
policy rule. Conditions CIM schema, both properties and actions associations are inherited to
the Policy classes. For example, the class ManagedElement is referenced
in the first group are termed
"rule-specific" conditions associations Dependency, Statistics and actions; those in MemberOfCollection. And,
the second group are
characterized as "reusable".
It Dependency association is important to understand that in turn referenced in the difference between a rule-
specific condition or action DependencyContext
association. At this very abstract and a reusable one is based on high level in the intent inheritance
hierarchy, the number of these associations is very small and their
semantics are quite general.
Many of these inherited associations convey additional semantics that are
not needed in understanding the policy administrator for Policy Core Information Model. In fact,
they are defined as OPTIONAL in the condition or action, rather than CIM Schema - since their cardinality
is "0..n" on all references. The PCIM document specifically discusses
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 13]
Internet Draft Policy Core Information Model July October 2000
on
what is necessary to support and instantiate. For example, through
subclassing of the current associations in which Dependency association, the condition or action
participates. Thus a reusable condition or action (that is, exact Dependency semantics
in PCIM are described.
So, one that
a policy administrator has created to be reusable) may at some point
in time be associated wonder what to do with exactly one policy rule, without thereby
becoming rule-specific.
There these other inherited associations.
The answer is no inherent difference between a rule-specific condition or
action "ignore them unless you need them." You would need them to
describe additional information and a reusable one. There are, however, differences in how
they are treated in a semantics for policy repository. data. For
example, it's natural it may be necessary to
make the access permissions capture statistical data for a rule-specific condition or action
identical to those PolicyRule
(either for the rule itself. It's also natural for in a rule-
specific condition repository or action to be removed from the for when it is executing in a
policy repository
at system). Some examples of statistical data for a rule are the same time
number of times it was downloaded, the rule is. With reusable number of times its conditions
were evaluated, and actions,
on the other hand, access permissions and existence criteria must number of times its actions were executed.
(These types of data would be
expressible without reference to described in a policy rule.
The preceding paragraph does not contain subclass of
CIM_StatisticalInformation.) In these cases, the Statistics association
inherited from ManagedElement to PolicyRule may be used to describe the
tie between an exhaustive list instance of a PolicyRule and the
ways in which reusable set of statistics for it.
5. Details of the Model
The following subsections discuss several specific issues related to the
Policy Core Information Model.
5.1. Reusable versus Rule-Specific Conditions and rule-specific Actions
Policy conditions should and policy actions can be treated
differently. Its purpose is merely to justify making partitioned into two groups:
ones associated with a semantic
distinction between rule-specific single policy rule, and ones that are reusable, and then reflecting
this distinction in
the sense that they may be associated with more than one policy model itself.
An issue is highlighted by reusable rule.
Conditions and rule-specific policy actions in the first group are termed "rule-specific"
conditions and policy actions: actions; those in the lack of a programmatic capability
for expressing complex constraints involving multiple associations.
Taking PolicyCondition as an example, there are two aggregations to
look at. PolicyConditionInPolicyRule has the cardinality * at both
ends, and PolicyConditionInPolicyRepository has the cardinality * at
the PolicyCondition end, and [0..1] at the PolicyRepository end.
Globally, these cardinalities second group are correct. However, there's more characterized as
"reusable".
It is important to understand that the story, which only becomes clear if we examine the cardinalities
separately for the two cases of difference between a rule-specific PolicyCondition
condition or action and a reusable one.
For a rule-specific PolicyCondition, one is based on the cardinality intent of
PolicyConditionInPolicyRule at the PolicyRule end is [1..1], rather
than [0..n] (recall that * is an abbreviation
policy administrator for [0..n]), since the condition is unique to one policy rule. And the cardinality of
PolicyConditionInPolicyRepository at the PolicyRepository end is
[0..0], since or action, rather than on the condition is not
current associations in which the "re-usable" repository.
This is OK, since these are both subsets of the specified
cardinalities.
For condition or action participates. Thus
a reusable PolicyCondition, however, the cardinality of
PolicyConditionInPolicyRepository at the PolicyRepository end is
[1..1], since the condition must or action (that is, one that a policy administrator
has created to be in the repository. And, the
cardinality of PolicyConditionInPolicyRule reusable) may at the PolicyRule end is
[0..n]. This last some point is important: a reusable PolicyCondition may in time be associated with 0, 1, or more than 1 PolicyRules, via
exactly the
same association PolicyConditionInPolicyRule that binds one policy rule, without thereby becoming rule-specific.
There is no inherent difference between a rule-
specific rule-specific condition to its PolicyRule.
Moore, et al. Expires: Jul 2000 + 6 months [Page 14]
Internet Draft Policy Core Information Model July 2000
Currently the only way to document constraints of this type is
textually. More formal methods for documenting complex constraints
are needed.
5.2. Roles
5.2.1. Roles or
action and Role Combinations
The concept of role is central to the design of the entire Policy
Framework. The idea behind roles is a simple reusable one. Rather than
configuring, and then later having to update the configuration of,
hundreds or thousands (or more) of resources There are, however, differences in how they
are treated in a network, a policy
administrator assigns each resource repository. For example, it's natural to one or more roles, and then
specifies make
the policies for each of these roles. The Policy Framework
is then responsible access permissions for configuring each of the resources associated
with a role in such a way that it behaves according rule-specific condition or action identical
to the policies
specified those for that role. When network behavior must be changed, the
policy administrator can perform rule itself. It's also natural for a single update rule-specific
condition or action to be removed from the policy for a
role, and repository at the Policy Framework will ensure that same
time the necessary
configuration updates are performed rule is. With reusable conditions and actions, on all the resources playing that
role.
A more formal definition of a role is as follows:
A role is a type of attribute that is used to select one or more
policies for a set of entities and/or components from among a much
larger set of available policies.
Roles can other
hand, access permissions and existence criteria must be combined together. Here is expressible
without reference to a formal definition policy rule.
Moore, et al. Expires: Oct 2000 + 6 months [Page 14]
Internet Draft Policy Core Information Model October 2000
The preceding paragraph does not contain an exhaustive list of a
"role-combination":
A role-combination the ways
in which reusable and rule-specific conditions should be treated
differently. Its purpose is merely to justify making a set semantic
distinction between rule-specific and reusable, and then reflecting this
distinction in the policy model itself.
An issue is highlighted by reusable and rule-specific policy conditions
and policy actions: the lack of attributes that a programmatic capability for expressing
complex constraints involving multiple associations. Taking
PolicyCondition as an example, there are used two aggregations to select
one or look at.
PolicyConditionInPolicyRule has the cardinality * at both ends, and
PolicyConditionInPolicyRepository has the cardinality * at the
PolicyCondition end, and [0..1] at the PolicyRepository end.
Globally, these cardinalities are correct. However, there's more policies for a set of entities and/or components from
among a much larger set of available policies. As to the examples
below illustrate,
story, which only becomes clear if we examine the selection process cardinalities
separately for a role combination
chooses policies associated with the combination itself, policies
associated with each two cases of its sub-combinations, a rule-specific PolicyCondition and policies
associated with each of a
reusable one.
For a rule-specific PolicyCondition, the individual roles in cardinality of
PolicyConditionInPolicyRule at the role-
combination.
It PolicyRule end is important to note [1..1], rather than
[0..n] (recall that a role * is more than an attribute. A role
defines a particular function of an entity or component that can be
used abbreviation for [0..n]), since the condition
is unique to identify particular behavior associated with that entity or
component. This difference one policy rule. And the cardinality of
PolicyConditionInPolicyRepository at the PolicyRepository end is critical, and [0..0],
since the condition is most easily understood
by thinking not in the "re-usable" repository. This is OK,
since these are both subsets of the specified cardinalities.
For a role as a selector. When used reusable PolicyCondition, however, the cardinality of
PolicyConditionInPolicyRepository at the PolicyRepository end is [1..1],
since the condition must be in this manner, one
role (or role-combination) selects a different set the repository. And, the cardinality of policies
PolicyConditionInPolicyRule at the PolicyRule end is [0..n]. This last
point is important: a reusable PolicyCondition may be associated with 0,
1, or more than 1 PolicyRules, via exactly the same association
PolicyConditionInPolicyRule that binds a
different role (or role-combination) does.
Roles and role-combinations are especially useful in selecting which
policies are applicable rule-specific condition to a particular set of entities or components
when its
PolicyRule.
Currently the policy repository can store thousands or hundreds only way to document constraints of
thousands this type is textually.
More formal methods for documenting complex constraints are needed.
5.2. Roles
5.2.1. Roles and Role Combinations
The concept of policies. This use emphasizes role is central to the ability design of the role (or
Moore, et al. Expires: Jul 2000 + 6 months [Page 15]
Internet Draft entire Policy Core Information Model July 2000
role-combination)
Framework. The idea behind roles is a simple one. Rather than
configuring, and then later having to select update the small subset configuration of,
hundreds or thousands (or more) of policies that are
applicable from resources in a huge set of policies that are available.
An example will illustrate how role-combinations actually work.
Suppose an installation has three roles defined for interfaces:
"Ethernet", "Campus", network, a policy
administrator assigns each resource to one or more roles, and "WAN". In then
specifies the policies for each of these roles. The Policy Repository, some
policy rules could be Framework is
then responsible for configuring each of the resources associated with the a
role "Ethernet"; these rules
would apply in such a way that it behaves according to all Ethernet interfaces, regardless of whether they
were on the campus side or the WAN side. Other rules could policies specified
for that role. When network behavior must be
associated with the role-combination "Campus"+"Ethernet"; these rules
would apply to changed, the campus-side Ethernet interfaces, but not policy
Moore, et al. Expires: Oct 2000 + 6 months [Page 15]
Internet Draft Policy Core Information Model October 2000
administrator can perform a single update to those
on the WAN side. Finally, policy for a third set of rules could be associated
with role, and
the role-combination "Ethernet"+"WAN"; these rules would apply to Policy Framework will ensure that the WAN-side Ethernet interfaces, but not to those necessary configuration updates
are performed on all the campus side.
(The roles in a role-combination appear in alphabetical order in these
examples, because resources playing that is how they appear in the information model.)
If we have role.
A more formal definition of a specific interface role is as follows:
A that's associated with the role-
combination "Ethernet"+"WAN", we see that it should have three
categories role is a type of policy rules applied attribute that is used to it: those for the "Ethernet"
role, those for the "WAN" role, and those for the role-combination
"Ethernet"+"WAN". Going select one step further, if interface B is
associated with the role-combination "branch-office"+"Ethernet"+"WAN",
then B should have seven categories of policy rules applied to it -
those associated with the following role-combinations:
o "branch-office"
o "Ethernet"
o "WAN"
o "branch-office"+"Ethernet"
o "branch-office"+"WAN"
o "Ethernet"+"WAN"
o "branch-office"+"Ethernet"+"WAN".
In order to get all of the right policy rules or more
policies for a resource like
interface B, a PDP must expand the single role-combination it receives
for B into this list set of seven role-combinations, and then retrieve entities and/or components from the Policy Repository the corresponding seven sets among a much
larger set of policy
rules. Of course this example available policies.
Roles can be combined together. Here is unusually complicated: the normal
case will involve expanding a two-role combination into three values
identifying three sets of policy rules.
Role-combinations also help to simplify somewhat the problem formal definition of
identifying conflicts between policy rules. With role-combinations,
it a "role-
combination":
A role-combination is possible for a policy administrator set of attributes that are used to specify select one
or more policies for a set of policy
rules for campus-side Ethernet interfaces, and entities and/or components from among a second
much larger set of policy
rules available policies. As the examples below
illustrate, the selection process for WAN-side Ethernet interfaces, without having to worry about
conflicts between a role combination chooses
policies associated with the two sets combination itself, policies associated
with each of rules. The policy administrator
simply "turns off" conflict detection for these two sets its sub-combinations, and policies associated with each
of rules, by
telling the policy management system that the individual roles "Campus" and "WAN"
are incompatible with each other. This indicates that the role
combination will never occur, and therefore conflicts will never
occur. In some cases the technology itself might identify
Moore, et al. Expires: Jul 2000 + 6 months [Page 16]
Internet Draft Policy Core Information Model July 2000
incompatible roles: "Ethernet" and "FrameRelay", for example. But
for less precise terms like "Campus" and "WAN", the policy
administrator must say whether they identify incompatible roles.
When in the policy administrator does this, there are three effects:
1. If an interface has assigned role-combination.
It is important to it note that a role-combination involving
both "Campus" and "WAN", then the policy management system can flag
it as role is more than an error.
2. If attribute. A role
defines a policy rule is particular function of an entity or component that can be used
to identify particular behavior associated with a role-combination involving
both "Campus" that entity or component.
This difference is critical, and "WAN", then the policy management system can flag
it is most easily understood by thinking of
a role as an error.
3. If the policy management system sees two policy rules, where a selector. When used in this manner, one is
tied to the role "Campus" (or to role-
combination) selects a role-combination that includes
the role "Campus") and the other is tied to the different set of policies than a different role "WAN"
(or role-combination) does.
Roles and role-combinations are especially useful in selecting which
policies are applicable to a
role-combination that includes the role "WAN"), then particular set of entities or components
when the system
does not need to look for conflicts between the two policy rules:
because repository can store thousands or hundreds of the incompatible roles, the two rules cannot possibly
conflict.
+-------------------+
| Policy Repository |
+-------------------+
V
V retrieval thousands
of policy
V
+---------+
| PDP/PEP |
+---------+
v
v application policies. This use emphasizes the ability of policy
v
+----------------+
| Network Entity |
+----------------+
Figure 4. Retrieval and Application the role (or role-
combination) to select the small subset of policies that are applicable
from a Policy
Figure 4, which is introduced only as an example huge set of policies that are available.
An example will illustrate how role-combinations actually work. Suppose
an installation has three roles defined for interfaces: "Ethernet",
"Campus", and "WAN". In the Policy
Framework might Repository, some policy rules could
be implemented by a collection associated with the role "Ethernet"; these rules would apply to all
Ethernet interfaces, regardless of network components,
illustrates how roles operate within whether they were on the Policy Framework. Because campus side
or the distinction between them is WAN side. Other rules could be associated with the role-
combination "Campus"+"Ethernet"; these rules would apply to the campus-
side Ethernet interfaces, but not important to this discussion, those on the
PDP and WAN side. Finally, a
third set of rules could be associated with the PEP are combined in one box. The points illustrated here role-combination
"Ethernet"+"WAN"; these rules would apply equally well, though, to an environment where the PDP and WAN-side Ethernet
interfaces, but not to those on the
PEP are implemented separately.
A role represents a functional characteristic or capability of campus side. (The roles in a
resource to which policies are applied. Examples of roles include
Backbone interface, Frame Relay interface, BGP-capable router, web role-
combination appear in alphabetical order in these examples, because that
is how they appear in the information model.)
If we have a specific interface A that's associated with the role-
combination "Ethernet"+"WAN", we see that it should have three categories
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 17] 16]
Internet Draft Policy Core Information Model July October 2000
server, firewall, etc. The multiple roles assigned to a single
resource are combined to form that resource's role combination. Role
combinations are represented in the PCIM by values
of the PolicyRoles
property in the PolicyRule class. A PDP uses policy roles as follows
to identify the policies it needs to be aware of:
1. The PDP learns in some way the list of roles that its PEPs play.
This information might be configured at the PDP, the PEPs might
supply it rules applied to it: those for the PDP, or the PDP might retrieve it from a
repository.
2. Using repository-specific means, the PDP determines where to look "Ethernet" role, those for policy rules that might apply to it.
3. Using
the roles "WAN" role, and role-combinations it received from its PEPs
as indicated in the examples above, those for the PDP role-combination "Ethernet"+"WAN".
Going one step further, if interface B is able to locate and
retrieve associated with the role-
combination "branch-office"+"Ethernet"+"WAN", then B should have seven
categories of policy rules that are relevant applied to it.
5.2.2. The PolicyRoles Property
As indicated earlier, PolicyRoles is a property it - those associated with a
policy rule. It is an array holding "role combinations" for the policy
rule, and correlates with the roles defined for a network resource.
Using the PolicyRoles property, it is possible
following role-combinations:
o "branch-office"
o "Ethernet"
o "WAN"
o "branch-office"+"Ethernet"
o "branch-office"+"WAN"
o "Ethernet"+"WAN"
o "branch-office"+"Ethernet"+"WAN".
In order to mark a get all of the right policy rule
as applying, rules for example, to a Frame Relay resource like
interface or to B, a backbone
ATM interface. The PolicyRoles property take strings PDP must expand the single role-combination it receives
for B into this list of seven role-combinations, and then retrieve from
the form:
<RoleName>[&&<RoleName>]*
Each value Policy Repository the corresponding seven sets of policy rules. Of
course this property represents a role combination, including example is unusually complicated: the special normal case of a "combination" containing only one role. As the
format indicates, the role names in will
involve expanding a role two-role combination are ANDed
together to form a single selector. The multiple into three values identifying
three sets of the
PolicyRoles property are logically ORed, policy rules.
Role-combinations also help to make simplify somewhat the problem of
identifying conflicts between policy rules. With role-combinations, it
is possible for a policy rule administrator to have multiple selectors.
The individual role names in specify one set of policy rules
for campus-side Ethernet interfaces, and a role combination must appear in
alphabetical order (according to the collating sequence second set of policy rules for UCS-2
characters),
WAN-side Ethernet interfaces, without having to make worry about conflicts
between the string matches work correctly. two sets of rules. The role
names used in an environment are specified policy administrator simply "turns
off" conflict detection for these two sets of rules, by telling the
policy
administrator.
5.3. Local Time management system that the roles "Campus" and UTC Time in PolicyTimePeriodConditions
An instance of PolicyTimePeriodCondition has up to five properties "WAN" are
incompatible with each other. This indicates that represent times: TimePeriod, MonthOfYearMask, DayOfMonthMask,
DayOfWeekMask, the role combination
will never occur, and TimeOfDayMask. All of therefore conflicts will never occur. In some
cases the time-related properties
in technology itself might identify incompatible roles:
"Ethernet" and "FrameRelay", for example. But for less precise terms
like "Campus" and "WAN", the policy administrator must say whether they
identify incompatible roles.
When the policy administrator does this, there are three effects:
1. If an instance of PolicyTimePeriodCondition represent one of two types
of times: local time at interface has assigned to it a role-combination involving both
"Campus" and "WAN", then the place where policy management system can flag it as
an error.
2. If a policy rule is applied, or
UTC time. The property LocalOrUtcTime indicates which time
representation applies to associated with a role-combination involving both
"Campus" and "WAN", then the policy management system can flag it as
an instance of PolicyTimePeriodCondition. error.
3. If the policy management system sees two policy rules, where one is
tied to the role "Campus" (or to a role-combination that includes the
role "Campus") and the other is tied to the role "WAN" (or to a role-
combination that includes the role "WAN"), then the system does not
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 18] 17]
Internet Draft Policy Core Information Model July October 2000
Since the PCIM provides only for local time and UTC time, a Policy
Management Tool that provides for other time representations (for
example, a fixed time at a particular location) will
need to map from
these other representations to either local time or UTC time. An
example will illustrate look for conflicts between the nature two policy rules: because of
the incompatible roles, the two rules cannot possibly conflict.
+-------------------+
| Policy Repository |
+-------------------+
V
V retrieval of this mapping.
Suppose a policy rule
V
+---------+
| PDP/PEP |
+---------+
v
v application of policy
v
+----------------+
| Network Entity |
+----------------+
Figure 4. Retrieval and Application of a Policy
Figure 4, which is tied to the hours introduced only as an example of operation for how the Policy
Framework might be implemented by a Help
Desk: 0800 to 2000 Monday through Friday [US] Eastern Time. In order collection of network components,
illustrates how roles operate within the Policy Framework. Because the
distinction between them is not important to express these times this discussion, the PDP and
the PEP are combined in PolicyTimePeriodCondition, one box. The points illustrated here apply
equally well, though, to an environment where the PDP and the PEP are
implemented separately.
A role represents a management tool
must convert them functional characteristic or capability of a
resource to UTC times. (They which policies are not local times, because
they refer applied. Examples of roles include
Backbone interface, Frame Relay interface, BGP-capable router, web
server, firewall, etc. The multiple roles assigned to a single time interval worldwide, not to intervals tied
resource are combined to form that resource's role combination. Role
combinations are represented in the local clocks at PCIM by values of the locations where PolicyRoles
property in the PolicyRule is being
applied.) As reference [10] points out, mapping from [US] Eastern
Time class. A PDP uses policy roles as follows to UTC time is not simply a matter of applying an offset: the
offset between [US] Eastern Time and UTC time switches between -0500
and -0400 depending on whether Daylight Savings Time is in effect in
the US.
Suppose
identify the policy administrator's goal is policies it needs to have a policy rule be
valid from 0800 until 1200 [US] Eastern Time on every Monday, within
the overall time period from the beginning of 2000 until aware of:
1. The PDP learns in some way the end list of
2001. The Policy Management Tool could either roles that its PEPs play. This
information might be configured with at the
definition of what [US] Eastern Time means, PDP, the PEPs might supply it
to the PDP, or the PDP might retrieve it could be configured
with knowledge of from a repository.
2. Using repository-specific means, the PDP determines where to go to get this information. Reference [10]
contains further discussion of time zone definitions and where they look for
policy rules that might reside.
Armed with knowledge about [US] Eastern Time, apply to it.
3. Using the Policy Management
Tool would create however many instances of PolicyTimePeriodCondition roles and role-combinations it needed to represent received from its PEPs as
indicated in the desired intervals. Note that while there
is an increased number of PolicyTimePeriodCondition instances, there
is still just one PolicyRule, which examples above, the PDP is tied able to all the
PolicyTimePeriodCondition instances via locate and
retrieve the aggregation
PolicyRuleValidityPeriod. Here policy rules that are the first two of these instances:
1. TimePeriod: 20000101T050000/20000402T070000
DayOfWeekMask: { Monday }
TimeOfDayMask: T130000/T170000
LocalOrUtcTime: UTC
2. TimePeriod: 20000402T070000/20001029T070000
DayOfWeekMask: { Monday }
TimeOfDayMask: T120000/T160000
LocalOrUtcTime: UTC
There would be three more similar instances, for winter 2000-2001,
summer 2001, and winter 2001 up through December 31.
Had the example been chosen differently, there could have been even
more instances of PolicyTimePeriodCondition. If, for example, the relevant to it.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 19] 18]
Internet Draft Policy Core Information Model July October 2000
time interval had been from 0800 - 2200 [US] Eastern Time on Mondays,
instance 1 above would have split into two instances: one with
5.2.2. The PolicyRoles Property
As indicated earlier, PolicyRoles is a UTC
time interval of T130000/T240000 on Mondays, and another property associated with a UTC
time interval of T000000/T030000 on Tuesdays. So the end result would
have been ten instances of PolicyTimePeriodCondition, not five.
By restricting PolicyTimePeriodCondition to local time and UTC time,
the PCIM places policy
rule. It is an array holding "role combinations" for the difficult policy rule, and expensive task of mapping from
"human" time representations to machine-friendly ones in
correlates with the Policy
Management Tool. Another approach would have been to place in
PolicyTimePeriodCondition a means of representing roles defined for a named time zone,
such as [US] Eastern Time. This, however, would have passed the
difficult mapping responsibility down to network resource. Using the PDPs and PEPs. It
PolicyRoles property, it is
better possible to have mark a mapping such policy rule as the one described above done once in applying,
for example, to a Policy Management Tool, rather than having it done over and over in
each of the PDPs (and possibly PEPs) that need Frame Relay interface or to apply a PolicyRule.
5.4. CIM Data Types
Since PCIM extends the CIM Schema, a correspondence between data types
used in both CIM and PCIM is needed. backbone ATM interface.
The following CIM data types are
used in PolicyRoles property take strings of the class definitions that follow in Sections 6 and 7:
o uint8 unsigned 8-bit integer
o uint16 unsigned 16-bit integer
o boolean Boolean
o string UCS-2 string.
Strings form:
<RoleName>[&&<RoleName>]*
Each value of this property represents a role combination, including the
special case of a "combination" containing only one role. As the format
indicates, the role names in CIM a role combination are stored as UCS-2 characters, where each character is
encoded in two octets. Thus string values may need ANDed together to be converted
when moving between a CIM environment and one that uses
form a different
string encoding. For example, in an LDAP-accessible directory,
attributes single selector. The multiple values of type DirectoryString the PolicyRoles property
are stored in UTF-8 format. RFC
2279 [7] explains how logically ORed, to convert between these two formats.
When make it is applied to a CIM string, possible for a MaxLen value refers policy rule to the
maximum number of characters have
multiple selectors.
The individual role names in the string, rather than a role combination must appear in
alphabetical order (according to the maximum
number of octets.
In addition collating sequence for UCS-2
characters), to make the CIM data types listed above, the association
classes string matches work correctly. The role names
used in Section 7 use the following type:
o <classname> ref strongly typed reference.
6. Class Definitions
There an environment are a significant number of differences between CIM and LDAP
class specifications. The ones that are relevant to specified by the abbreviated
class specifications policy administrator.
5.3. Local Time and UTC Time in this document are the following:
Moore, et al. Expires: Jul 2000 + 6 months [Page 20]
Internet Draft Policy Core Information Model July 2000
o Instead PolicyTimePeriodConditions
An instance of LDAP's three class types (abstract, auxiliary,
structural), CIM PolicyTimePeriodCondition has only two: abstract up to five properties that
represent times: TimePeriod, MonthOfYearMask, DayOfMonthMask,
DayOfWeekMask, and instantiable. The
type TimeOfDayMask. All of a CIM class is indicated by the Boolean qualifier ABSTRACT.
o CIM uses the term "property" for what LDAP terms time-related properties in
an "attribute".
o CIM uses the array notation "[ ]" to indicate that a property is
multi-valued. CIM defines three instance of PolicyTimePeriodCondition represent one of two types of arrays: bags (contents
are unordered, duplicates allowed), ordered bags (contents are
ordered but duplicates are allowed) and indexed arrays (contents
are ordered and no duplicates are allowed).
o CIM classes and properties are identified by name, not by OID.
o CIM classes use
times: local time at the place where a different naming scheme for native
implementations, than LDAP. The CIM naming scheme is documented in
Appendix A since it policy rule is not critical applied, or UTC
time. The property LocalOrUtcTime indicates which time representation
applies to understanding an instance of PolicyTimePeriodCondition.
Since the
information model, and PCIM provides only applies when communicating with a
native CIM implementation.
o In LDAP, attribute definitions are global, for local time and the same attribute
may appear in multiple classes. In CIM, a property is defined
within the scope of UTC time, a single class definition. The property may be
inherited into subclasses of the class in which it is defined, but
otherwise it cannot appear in Policy
Management Tool that provides for other classes. One side effect time representations (for
example, a fixed time at a particular location) will need to map from
these other representations to either local time or UTC time. An example
will illustrate the nature of this difference mapping.
Suppose a policy rule is that CIM property names tend tied to be much shorter
than LDAP attribute names, since they are implicitly scoped by the
name hours of the class in which they are defined.
There is also operation for a notational convention that this document follows, Help Desk:
0800 to
improve readability. 2000 Monday through Friday [US] Eastern Time. In CIM, all class and property names order to
express these times in PolicyTimePeriodCondition, a management tool must
convert them to UTC times. (They are
prefixed with not local times, because they refer
to a single time interval worldwide, not to intervals tied to the characters "CIM_". These prefixes have been omitted
throughout this document, with one exception regarding naming,
documented in Appendix A.
For local
clocks at the complete definition of locations where the CIM specification language, see PolicyRule is being applied.) As
reference [2].
6.1. The Abstract Class "Policy"
The abstract class Policy collects several properties that may be
included in instances of any [10] points out, mapping from [US] Eastern Time to UTC time is
not simply a matter of applying an offset: the Core Policy classes (or their
subclasses). For convenience, the two properties that Policy inherits
from ManagedElement offset between [US]
Eastern Time and UTC time switches between -0500 and -0400 depending on
whether Daylight Savings Time is in effect in the CIM schema are shown here as well.
The class definition US.
Suppose the policy administrator's goal is as follows:
NAME Policy
DESCRIPTION An abstract class with four properties for
describing to have a policy-related instance.
DERIVED FROM ManagedElement
ABSTRACT TRUE
PROPERTIES CommonName (CN) policy rule be valid
from 0800 until 1200 [US] Eastern Time on every Monday, within the
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 21] 19]
Internet Draft Policy Core Information Model July October 2000
PolicyKeywords[ ]
// Caption (inherited)
// Description (inherited)
6.1.1. The Property "CommonName (CN)"
overall time period from the beginning of 2000 until the end of 2001.
The CN, or CommonName, property corresponds to Policy Management Tool could either be configured with the X.500 attribute
commonName (cn). In X.500 this property specifies one definition
of what [US] Eastern Time means, or more user-
friendly names (typically only one name) by which an object is
commonly known, names that conform it could be configured with knowledge
of where to go to get this information. Reference [10] contains further
discussion of time zone definitions and where they might reside.
Armed with knowledge about [US] Eastern Time, the naming conventions Policy Management Tool
would create however many instances of PolicyTimePeriodCondition it
needed to represent the
country or culture with desired intervals. Note that while there is an
increased number of PolicyTimePeriodCondition instances, there is still
just one PolicyRule, which the object is associated. In tied to all the CIM
model, however, PolicyTimePeriodCondition
instances via the CommonName property is single-valued.
NAME CN
DESCRIPTION A user-friendly name of a policy-related object.
SYNTAX string
6.1.2. The Multi-valued Property "PolicyKeywords"
This property provides a set aggregation PolicyRuleValidityPeriod. Here are the
first two of one or these instances:
1. TimePeriod: 20000101T050000/20000402T070000
DayOfWeekMask: { Monday }
TimeOfDayMask: T130000/T170000
LocalOrUtcTime: UTC
2. TimePeriod: 20000402T070000/20001029T070000
DayOfWeekMask: { Monday }
TimeOfDayMask: T120000/T160000
LocalOrUtcTime: UTC
There would be three more keywords that a policy
administrator may use to assist in characterizing or categorizing a
policy object. Keywords are similar instances, for winter 2000-2001, summer
2001, and winter 2001 up through December 31.
Had the example been chosen differently, there could have been even more
instances of PolicyTimePeriodCondition. If, for example, the
time interval had been from 0800 - 2200 [US] Eastern Time on Mondays,
instance 1 above would have split into two instances: one with a UTC
time interval of two types:
o Keywords defined in this document, or in documents that define
subclasses T130000/T240000 on Mondays, and another with a UTC time
interval of T000000/T030000 on Tuesdays. So the classes defined in this document. These keywords
provide a vendor-independent, installation-independent way end result would have
been ten instances of
characterizing policy objects.
o Installation-dependent keywords for characterizing policy objects.
Examples include "Engineering", "Billing", PolicyTimePeriodCondition, not five.
By restricting PolicyTimePeriodCondition to local time and "Review in December
2000".
This document defines UTC time, the following keywords: "UNKNOWN",
"CONFIGURATION", "USAGE", "SECURITY", "SERVICE", "MOTIVATIONAL",
"INSTALLATION",
PCIM places the difficult and "EVENT". These concepts were defined earlier in
Section 2.
One additional keyword is defined: "POLICY". The role expensive task of this
keyword is mapping from "human" time
representations to identify policy-related instances that would not
otherwise be identifiable as being related to policy. It may be
needed machine-friendly ones in some repository implementations.
Documents that define subclasses of the Policy Core Information Model
classes SHOULD define additional keywords Management Tool.
Another approach would have been to characterize instances of
these subclasses. By convention, keywords defined in conjunction with
class definitions are in uppercase. Installation-defined keywords can
be place in any case.
The property definition PolicyTimePeriodCondition a
means of representing a named time zone, such as [US] Eastern Time.
This, however, would have passed the difficult mapping responsibility
down to the PDPs and PEPs. It is better to have a mapping such as follows:
NAME PolicyKeywords
DESCRIPTION A set the
one described above done once in a Policy Management Tool, rather than
having it done over and over in each of keywords for characterizing /categorizing
policy objects. the PDPs (and possibly PEPs) that
need to apply a PolicyRule.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 22] 20]
Internet Draft Policy Core Information Model July October 2000
SYNTAX string
6.1.3. The Property "Caption" (Inherited from ManagedElement)
This property provides a one-line description of
5.4. CIM Data Types
Since PCIM extends the CIM Schema, a policy-related
object.
NAME Caption
DESCRIPTION A one-line description of this policy-related
object.
SYNTAX string
6.1.4. correspondence between data types
used in both CIM and PCIM is needed. The Property "Description" (Inherited from ManagedElement)
This property provides a longer description than that provided by following CIM data types are
used in the
caption property.
NAME Description
DESCRIPTION A long description of this policy-related object.
SYNTAX string
6.2. The Class "PolicyGroup"
This class is a generalized aggregation container. It enables either
PolicyRules or PolicyGroups, but not both, to be aggregated in a
single container. Loops, including the degenerate case of a
PolicyGroup definitions that contains itself, are not allowed when PolicyGroups
contain other PolicyGroups.
PolicyGroups follow in Sections 6 and their nesting capabilities 7:
o uint8 unsigned 8-bit integer
o uint16 unsigned 16-bit integer
o boolean Boolean
o string UCS-2 string.
Strings in CIM are shown stored as UCS-2 characters, where each character is
encoded in Figure 5
below. Note that two octets. Thus string values may need to be converted when
moving between a PolicyGroup can nest other PolicyGroups, CIM environment and there one that uses a different string
encoding. For example, in an LDAP-accessible directory, attributes of
type DirectoryString are stored in UTF-8 format. RFC 2279 [7] explains
how to convert between these two formats.
When it is no restriction on applied to a CIM string, a MaxLen value refers to the depth maximum
number of the nesting characters in sibling PolicyGroups.
+---------------------------------------------------+
| PolicyGroup |
| |
| +--------------------+ +-----------------+ |
| | PolicyGroup A | | PolicyGroup X | |
| | | | | |
| | +----------------+ | ooo | | |
| | | PolicyGroup A1 | | | | |
| | +----------------+ | | | |
| +--------------------+ +-----------------+ |
+---------------------------------------------------+
Figure 5. Overview of the PolicyGroup class
As a simple example, think string, rather than to the maximum number of
octets.
In addition to the highest level PolicyGroup shown CIM data types listed above, the association classes
in
Figure 5 above as a logon policy for US employees of a company. This
PolicyGroup may be called USEmployeeLogonPolicy, and may aggregate
several PolicyGroups that provide specialized rules per location.
Hence, PolicyGroup A Section 7 use the following type:
o <classname> ref strongly typed reference.
There is one obvious omission from this list of CIM data types: octet
strings. This is because CIM treats octet strings as a derived data
type. There are two forms of octet strings in Figure 5 above may define logon rules CIM - an ordered uint8
array for single-valued strings, and a string array for multi-valued
properties. Both are described by adding an "OctetString" qualifier
(meta-data) to the property. This qualifier functions exactly like an
SMIv2 (SNMP) Textual Convention, refining the syntax and semantics of the
existing CIM data type.
The first four numeric elements of both of the "OctetString"
representations are a length field. (The reason that the "numeric"
adjective is added to the previous sentence is that the string property
also includes '0' and 'x', as its first characters.) In both cases,
these 4 numeric elements (octets) are included in calculating the length.
For example, a single-valued octet string property having the value X'7C'
would be represented by the uint8 array, X'00 00 00 05 7C'.
The strings representing the individual values of a multi-valued property
qualified with the "OctetString" qualifier are constructed similarly:
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 23] 21]
Internet Draft Policy Core Information Model July October 2000
employees on
1. Take a value to be encoded as an octet string (we'll use X'7C' as
above), and prepend to it a four-octet length . The result is the West Coast, while another PolicyGroup might define
logon rules for
same, X'00 00 00 05 7C'.
2. Convert this to a character string by introducing '0' and 'x' at the Midwest (e.g., PolicyGroup X),
front, and so forth.
Note also that removing all white space. Thus we have the depth 12-character
string "0x000000057C". This string is the value of one of each PolicyGroup does not need to be the
same. Thus, array
elements in the WestCoast PolicyGroup might have several additional
layers CIM string array. Since CIM uses the UCS-2 character
set, it will require 24 octets to encode this 12-character string.
Mappings of PolicyGroups defined for any the PCIM to particular data models are not required to follow
this CIM technique of several reasons (different
locales, representing multi-valued octet strings as length-
prefixed character strings. In an LDAP mapping, for example, it would be
much more natural to simply use the Octet String syntax, and omit the
prepended length octets.
5.5. Comparison between CIM and LDAP Class Specifications
There are a number of subnets, etc.). differences between CIM and LDAP class
specifications. The PolicyRules ones that are therefore
contained at n levels from relevant to the USEmployeeLogonPolicyGroup. Compare abbreviated class
specifications in this document are listed below. These items are
included here to help introduce the Midwest PolicyGroup (PolicyGroup X), IETF community, which might directly
contain PolicyRules.
The class definition for PolicyGroup is as follows:
NAME PolicyGroup
DESCRIPTION A container for either a set of related PolicyRules
or a set already
familiar with LDAP, to CIM modeling, and by extension, to information
modeling in general.
o Instead of related PolicyGroups.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES NONE
No properties are defined for this class since it inherits all its
properties from Policy. The LDAP's three class exists to aggregate PolicyRules or
other PolicyGroups. It is directly types (abstract, auxiliary, structural),
CIM has only two: abstract and instantiable. In an
implementation, various key/identification properties MUST be defined. The keys for type of a native CIM implementation are defined in Appendix A,
Section 14.1.1. Keys class
is indicated by the Boolean qualifier ABSTRACT.
o CIM uses the term "property" for an what LDAP implementation are defined in terms an "attribute".
o CIM uses the
LDAP mapping of this information model [11].
6.3. The Class "PolicyRule"
This class represents the "If Condition then Action" semantics
associated with array notation "[ ]" to indicate that a policy. A PolicyRule condition, in the most general
sense, property is represented as either an ORed set of ANDed conditions
(Disjunctive Normal Form, or DNF) or an ANDed set
multi-valued. CIM defines three types 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 arrays: bags (contents are to be performed if
unordered, duplicates allowed), ordered bags (contents are ordered but
duplicates are allowed) and only if the PolicyRule condition
(whether it indexed arrays (contents are ordered and
no duplicates are allowed).
o CIM classes and properties are identified by name, not by OID.
o CIM classes use a different naming scheme for native implementations,
than LDAP. The CIM naming scheme is represented documented in DNF or CNF) evaluates Appendix A since it
is not critical to TRUE.
The conditions understanding the information model, and actions associated only
applies when communicating with a policy rule native CIM implementation.
o In LDAP, attribute definitions are modeled,
respectively, with subclasses of the classes PolicyCondition and
PolicyAction. These condition global, and action objects are tied to
instances of PolicyRule by the PolicyConditionInPolicyRule and
PolicyActionInPolicyRule aggregations.
As illustrated above same attribute may
appear in Section 3, multiple classes. In CIM, a policy rule property is defined within the
scope of a single class definition. The property may also be
associated with one or more policy time periods, indicating inherited
into subclasses of the
schedule according to class in which the policy rule it is active and inactive.
In this case defined, but otherwise it
cannot appear in other classes. One side effect of this difference is the PolicyRuleValidityPeriod aggregation
that
provides CIM property names tend to be much shorter than LDAP attribute
names, since they are implicitly scoped by the linkage.
A policy rule is illustrated conceptually name of the class in Figure 6. below.
which they are defined.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 24] 22]
Internet Draft Policy Core Information Model July October 2000
+------------------------------------------------+
| PolicyRule |
| |
| +--------------------+ +-----------------+ |
| | PolicyCondition(s) | | PolicyAction(s) | |
| +--------------------+ +-----------------+ |
| |
| +------------------------------+ |
| | PolicyTimePeriodCondition(s) | |
| +------------------------------+ |
+------------------------------------------------+
Figure
There is also a notational convention that this document follows, to
improve readability. In CIM, all class and property names are prefixed
with the characters "CIM_". These prefixes have been omitted throughout
this document, with one exception regarding naming, documented in
Appendix A.
For the complete definition of the CIM specification language, see
reference [2].
6. Overview Class Definitions
The following sections contain the definitions of the PolicyRule PCIM classes.
6.1. The Abstract Class "Policy"
The PolicyRule abstract class uses the property ConditionListType, to indicate
whether Policy collects several properties that may be
included in instances of any of the conditions for Core Policy classes (or their
subclasses). For convenience, the rule are in DNF or CNF. The
PolicyConditionInPolicyRule aggregation contains two additional properties to complete the representation of that Policy inherits
from ManagedElement in the rule's conditional
expression. CIM schema are shown here as well.
The first of these properties class definition is an integer to partition
the referenced conditions into one or more groups, and as follows:
NAME Policy
DESCRIPTION An abstract class with four properties for describing
a policy-related instance.
DERIVED FROM ManagedElement
ABSTRACT TRUE
PROPERTIES CommonName (CN)
PolicyKeywords[ ]
// Caption (inherited)
// Description (inherited)
6.1.1. The Property "CommonName (CN)"
The CN, or CommonName, property corresponds to the second X.500 attribute
commonName (cn). In X.500 this property specifies one or more user-
friendly names (typically only one name) by which an object is a
Boolean commonly
known, names that conform to indicate whether a referenced condition the naming conventions of the country or
culture with which the object is negated. An
example shows how ConditionListType and these two additional
properties provide a unique representation associated. In the CIM model, however,
the CommonName property is single-valued.
NAME CN
DESCRIPTION A user-friendly name of a policy-related object.
SYNTAX string
6.1.2. The Multi-valued Property "PolicyKeywords"
This property provides a set of conditions one or more keywords that a policy
administrator may use to assist in
either DNF characterizing or CNF.
Suppose we have categorizing a PolicyRule
policy object. Keywords are of one of two types:
Moore, et al. Expires: Oct 2000 + 6 months [Page 23]
Internet Draft Policy Core Information Model October 2000
o Keywords defined in this document, or in documents that aggregates five PolicyConditions C1
through C5, with define
subclasses of the following values classes defined in the properties this document. These keywords
provide a vendor-independent, installation-independent way of
characterizing policy objects.
o Installation-dependent keywords for characterizing policy objects.
Examples include "Engineering", "Billing", and "Review in December
2000".
This document defines the five
PolicyConditionInPolicyRule associations:
C1: GroupNumber = 1, ConditionNegated = FALSE
C2: GroupNumber = 1, ConditionNegated = TRUE
C3: GroupNumber = 1, ConditionNegated = FALSE
C4: GroupNumber = 2, ConditionNegated = FALSE
C5: GroupNumber = 2, ConditionNegated = FALSE
If ConditionListType = DNF, then the overall condition for the
PolicyRule is:
(C1 AND (NOT C2) AND C3) OR (C4 AND C5)
On the other hand, if ConditionListType = CNF, then the overall
condition for the PolicyRule is:
(C1 OR (NOT C2) OR C3) AND (C4 OR C5)
In both cases, there following keywords: "UNKNOWN",
"CONFIGURATION", "USAGE", "SECURITY", "SERVICE", "MOTIVATIONAL",
"INSTALLATION", and "EVENT". These concepts were defined earlier in
Section 2.
One additional keyword is an unambiguous specification defined: "POLICY". The role of the overall
condition that this keyword
is tested to determine whether identify policy-related instances that would not otherwise be
identifiable as being related to perform policy. It may be needed in some
repository implementations.
Documents that define subclasses of the actions
associated Policy Core Information Model
classes SHOULD define additional keywords to characterize instances of
these subclasses. By convention, keywords defined in conjunction with the PolicyRule.
The
class definitions are in uppercase. Installation-defined keywords can be
in any case.
The property definition is as follows:
NAME PolicyRule PolicyKeywords
DESCRIPTION A set of keywords for characterizing /categorizing
policy objects.
SYNTAX string
6.1.3. The Property "Caption" (Inherited from ManagedElement)
This property provides a one-line description of a policy-related
object.
NAME Caption
DESCRIPTION A one-line description of this policy-related object.
SYNTAX string
6.1.4. The Property "Description" (Inherited from ManagedElement)
This property provides a longer description than that provided by the
caption property.
NAME Description
DESCRIPTION A long description of this policy-related object.
SYNTAX string
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 25] 24]
Internet Draft Policy Core Information Model July October 2000
DESCRIPTION The central class for representing the "If
Condition then Action" semantics associated with a
policy rule.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES Enabled
ConditionListType
RuleUsage
Priority
Mandatory
SequencedActions
PolicyRoles
6.2. The PolicyRule Class "PolicyGroup"
This class is directly instantiable. In an implementation,
various key/identification properties MUST a generalized aggregation container. It enables either
PolicyRules or PolicyGroups to be defined. The keys for aggregated in a
native CIM implementation single container.
Loops, including the degenerate case of a PolicyGroup that contains
itself, are defined in Appendix A, Section 14.1.2.
Keys for an LDAP implementation not allowed when PolicyGroups contain other PolicyGroups.
PolicyGroups and their nesting capabilities are defined shown in Figure 5 below.
Note that a PolicyGroup can nest other PolicyGroups, and there is no
restriction on the LDAP mapping depth of
this information model [11].
6.3.1. The Property "Enabled"
This property indicates whether the nesting in sibling PolicyGroups.
+---------------------------------------------------+
| PolicyGroup |
| |
| +--------------------+ +-----------------+ |
| | PolicyGroup A | | PolicyGroup X | |
| | | | | |
| | +----------------+ | ooo | | |
| | | PolicyGroup A1 | | | | |
| | +----------------+ | | | |
| +--------------------+ +-----------------+ |
+---------------------------------------------------+
Figure 5. Overview of the PolicyGroup class
As a policy rule is currently enabled,
from an administrative point simple example, think of view. Its purpose is to allow the highest level PolicyGroup shown in
Figure 5 above as a logon policy administrator to enable or disable for US employees of a policy rule without having
to add it to, or remove it from, the policy repository.
The property also supports the value 'enabledForDebug'. When the
property has this value, the entity evaluating the policy condition(s)
is being told to evaluate company. This
PolicyGroup may be called USEmployeeLogonPolicy, and may aggregate
several PolicyGroups that provide specialized rules per location. Hence,
PolicyGroup A in Figure 5 above may define logon rules for employees on
the conditions West Coast, while another PolicyGroup might define logon rules for
the policy rule, but Midwest (e.g., PolicyGroup X), and so forth.
Note also that the depth of each PolicyGroup does not need to perform be the actions if
same. Thus, the conditions evaluate to TRUE. This value
serves as a debug vehicle when attempting to determine what policies
would execute in a particular scenario, without taking WestCoast PolicyGroup might have several additional
layers of PolicyGroups defined for any actions of several reasons (different
locales, number of subnets, etc.). The PolicyRules are therefore
contained at n levels from the USEmployeeLogonPolicyGroup. Compare this
to
change state during the debugging. Midwest PolicyGroup (PolicyGroup X), which might directly contain
PolicyRules.
The property class definition for PolicyGroup is as follows:
NAME Enabled PolicyGroup
DESCRIPTION An enumeration indicating whether A container for either a policy rule is
administratively enabled, administratively
disabled, set of related PolicyRules or enabled
a set of related PolicyGroups.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES NONE
No properties are defined for debug mode.
SYNTAX uint16
VALUES enabled(1), disabled(2), enabledForDebug(3)
DEFAULT VALUE enabled(1)
6.3.2. this class since it inherits all its
properties from Policy. The Property "ConditionListType"
This property is used class exists to specify whether the list of policy conditions
associated with this policy rule is in disjunctive normal form (DNF) aggregate PolicyRules or conjunctive normal form (CNF). If this property is not present,
the list type defaults to DNF. The property definition is as follows:
NAME ConditionListType
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 26] 25]
Internet Draft Policy Core Information Model July October 2000
DESCRIPTION Indicates whether
other PolicyGroups. It is directly instantiable. In an implementation,
various key/identification properties MUST be defined. The keys for a
native CIM implementation are defined in Appendix A, Section 14.1.1.
Keys for an LDAP implementation are defined in the list LDAP mapping of policy conditions
associated with this policy rule is in disjunctive
normal form (DNF) or conjunctive normal form (CNF).
SYNTAX uint16
VALUES DNF(1), CNF(2)
DEFAULT VALUE DNF(1)
6.3.3.
information model [11].
6.3. The Property "RuleUsage" Class "PolicyRule"
This property is class represents the "If Condition then Action" semantics associated
with a free-form string that recommends how this policy
should be used. The property definition policy. A PolicyRule condition, in the most general sense, is
represented as follows:
NAME RuleUsage
DESCRIPTION This property is used to provide guidelines on how
this policy should 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 used.
SYNTAX string
6.3.4. negated (NOT C) or
unnegated (C). The Property "Priority"
This property provides actions specified by a non-negative integer for prioritizing policy
rules relative PolicyRule are to each other. For policy rules that have this
property, larger integer values indicate higher priority. Since one
purpose of this property be performed
if and only if the PolicyRule condition (whether it is represented in DNF
or CNF) evaluates to allow specific, ad hoc policy rules to
temporarily override established policy rules, an instance that has
this property set has a higher priority than all instances that lack
it.
Prioritization among policy rules provides a basic mechanism for
resolving policy conflicts. TRUE.
The property definition is as follows:
NAME Priority
DESCRIPTION A non-negative integer for prioritizing this
PolicyRule relative to other PolicyRules. A larger
value indicates conditions and actions associated with a higher priority.
SYNTAX uint16
DEFAULT VALUE 0
6.3.5. The Property "Mandatory"
This property indicates whether evaluation (and possibly action
execution) policy rule are modeled,
respectively, with subclasses of a PolicyRule is mandatory or not. Its concept is
similar to the ability to mark packets for delivery or possible
discard, based on network traffic classes PolicyCondition and device load.
The evaluation
PolicyAction. These condition and action objects are tied to instances
of a PolicyRule MUST be attempted if the Mandatory
property value is TRUE. If by the Mandatory property value of PolicyConditionInPolicyRule and
PolicyActionInPolicyRule aggregations.
As illustrated above in Section 3, a
PolicyRule is FALSE, then policy rule may also be associated
with one or more policy time periods, indicating the evaluation of schedule according
to which the policy rule is "best effort" active and MAY be ignored.
The property definition inactive. In this case it is as follows:
Moore, et al. Expires: Jul 2000 + 6 months [Page 27]
Internet Draft Policy Core Information Model July 2000
NAME Mandatory
DESCRIPTION A flag indicating that the evaluation of the
PolicyConditions and execution of PolicyActions (if
PolicyRuleValidityPeriod aggregation that provides the condition list evaluates to TRUE) linkage.
A policy rule is required.
SYNTAX boolean
DEFAULT VALUE TRUE
6.3.6. The Property "SequencedActions"
This property gives a policy administrator a way of specifying how the
ordering illustrated conceptually in Figure 6. below.
+------------------------------------------------+
| PolicyRule |
| |
| +--------------------+ +-----------------+ |
| | PolicyCondition(s) | | PolicyAction(s) | |
| +--------------------+ +-----------------+ |
| |
| +------------------------------+ |
| | PolicyTimePeriodCondition(s) | |
| +------------------------------+ |
+------------------------------------------------+
Figure 6. Overview of the policy actions associated with this PolicyRule is to
be interpreted. Three values are supported:
o mandatory(1): Do Class
The PolicyRule class uses the actions in property ConditionListType, to indicate
whether the indicated order, or don't do
them at all.
o recommended(2): Do conditions for the actions rule are in DNF or CNF. The
PolicyConditionInPolicyRule aggregation contains two additional
properties to complete the indicated order if you can,
but if you can't do them in this order, do them in another order if
you can.
o dontCare(3): Do them -- I don't care about representation of the order.
When error / event reporting rule's conditional
expression. The first of these properties is addressed for an integer to partition the
referenced conditions 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
Moore, et al. Expires: Oct 2000 + 6 months [Page 26]
Internet Draft Policy Framework,
suitable codes will be defined for reporting that Core Information Model October 2000
provide a set unique representation of actions
could not be performed in an order specified as mandatory (and thus
were not performed at all), that a set of actions could not be
performed conditions in a recommended order (and moreover could not be performed
in any order), either DNF or that
CNF.
Suppose we have a set PolicyRule that aggregates five PolicyConditions C1
through C5, with the following values in the properties of the five
PolicyConditionInPolicyRule associations:
C1: GroupNumber = 1, ConditionNegated = FALSE
C2: GroupNumber = 1, ConditionNegated = TRUE
C3: GroupNumber = 1, ConditionNegated = FALSE
C4: GroupNumber = 2, ConditionNegated = FALSE
C5: GroupNumber = 2, ConditionNegated = FALSE
If ConditionListType = DNF, then the overall condition for the PolicyRule
is:
(C1 AND (NOT C2) AND C3) OR (C4 AND C5)
On the other hand, if ConditionListType = CNF, then the overall condition
for the PolicyRule is:
(C1 OR (NOT C2) OR C3) AND (C4 OR C5)
In both cases, there is an unambiguous specification of the overall
condition that is tested to determine whether to perform the actions could not be performed in a
recommended order (but were performed in a different order).
associated with the PolicyRule.
The
property class definition is as follows:
NAME SequencedActions PolicyRule
DESCRIPTION An enumeration indicating how to interpret the
action ordering indicated via the
PolicyActionInPolicyRule aggregation.
SYNTAX uint16
VALUES mandatory(1), recommended(2), dontCare(3)
DEFAULT VALUE dontCare(3)
6.3.7. The Multi-valued Property "PolicyRoles"
This property represents central class for representing the roles and role combinations "If Condition
then Action" semantics associated with a policy rule. Each value represents one role combination.
Since this
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES Enabled
ConditionListType
RuleUsage
Priority
Mandatory
SequencedActions
PolicyRoles
The PolicyRule class is a multi-valued property, more than one role combination
can directly instantiable. In an implementation,
various key/identification properties MUST be associated with a single policy rule. Each value is defined. The keys for a string
of the form
<RoleName>[&&<RoleName>]*
where the individual role names appear
native CIM implementation are defined in alphabetical order
(according to the collating sequence Appendix A, Section 14.1.2.
Keys for UCS-2). The property
definition is as follows: an LDAP implementation are defined in the LDAP mapping of this
information model [11].
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 28] 27]
Internet Draft Policy Core Information Model July October 2000
NAME PolicyRoles
DESCRIPTION A set of strings representing the roles and role
combinations associated with
6.3.1. The Property "Enabled"
This property indicates whether a policy rule. Each
value represents one role combination.
SYNTAX string
6.4. The Class "PolicyCondition"
The purpose rule is currently enabled, from
an administrative point of view. Its purpose is to allow a policy condition is
administrator to determine whether enable or not disable a policy rule without having to add it
to, or remove it from, the
set of actions (aggregated in policy repository.
The property also supports the PolicyRule that value 'enabledForDebug'. When the condition
applies to) should be executed or not. For
property has this value, the purposes of entity evaluating the Policy
Core Information Model, all that matters about an individual
PolicyCondition policy condition(s) is that it evaluates to TRUE or FALSE. (The
individual PolicyConditions associated with a PolicyRule are combined
being told to form a compound expression in either DNF or CNF, but this is
accomplished via the ConditionListType property, discussed above, and
by evaluate the properties of conditions for the PolicyConditionInPolicyRule aggregation,
introduced above and discussed further in Section 7.6 below.) A
logical structure within an individual PolicyCondition may also be
introduced, policy rule, but this would have not to be done in a
perform the actions if the conditions evaluate to TRUE. This value
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 property definition is as follows:
NAME Enabled
DESCRIPTION An enumeration indicating whether a policy rule is
administratively enabled, administratively disabled,
or enabled for debug mode.
SYNTAX uint16
VALUES enabled(1), disabled(2), enabledForDebug(3)
DEFAULT VALUE enabled(1)
6.3.2. The Property "ConditionListType"
This property is used to specify whether the list of policy conditions
associated with this policy rule is in disjunctive normal form (DNF) or
conjunctive normal form (CNF). If this property is not present, the list
type defaults to DNF. The property definition is as follows:
NAME ConditionListType
DESCRIPTION Indicates whether the list of policy conditions
associated with this policy rule is in disjunctive
normal form (DNF) or conjunctive normal form (CNF).
SYNTAX uint16
VALUES DNF(1), CNF(2)
DEFAULT VALUE DNF(1)
6.3.3. The Property "RuleUsage"
This property is a free-form string that recommends how this policy
should be used. The property definition is as follows:
NAME RuleUsage
DESCRIPTION This property is used to provide guidelines on how
this policy should be used.
SYNTAX string
Moore, et al. Expires: Oct 2000 + 6 months [Page 28]
Internet Draft Policy Core Information Model October 2000
6.3.4. The Property "Priority"
This property provides a non-negative integer for prioritizing policy
rules relative to each other. Larger integer values indicate higher
priority. Since one purpose of this property is to allow specific, ad
hoc policy rules to temporarily override established policy rules, an
instance that has this property set has a higher priority than all
instances that use or set the default value of zero.
Prioritization among policy rules provides a basic mechanism for
resolving policy conflicts.
The property definition is as follows:
NAME Priority
DESCRIPTION A non-negative integer for prioritizing this
PolicyRule relative to other PolicyRules. A larger
value indicates a higher priority.
SYNTAX uint16
DEFAULT VALUE 0
6.3.5. The Property "Mandatory"
This property indicates whether evaluation (and possibly action
execution) of a PolicyRule is mandatory or not. Its concept is similar
to the ability to mark packets for delivery or possible discard, based on
network traffic and device load.
The evaluation of a PolicyRule MUST be attempted if the Mandatory
property value is TRUE. If the Mandatory property value of a PolicyRule
is FALSE, then the evaluation of the rule is "best effort" and MAY be
ignored.
The property definition is as follows:
NAME Mandatory
DESCRIPTION A flag indicating that the evaluation of the
PolicyConditions and execution of PolicyActions (if
the condition list evaluates to TRUE) is required.
SYNTAX boolean
DEFAULT VALUE TRUE
6.3.6. The Property "SequencedActions"
This property gives a policy administrator a way of specifying how the
ordering of the policy actions associated with this PolicyRule is to be
interpreted. Three values are supported:
o mandatory(1): Do the actions in the indicated order, or don't do
them at all.
Moore, et al. Expires: Oct 2000 + 6 months [Page 29]
Internet Draft Policy Core Information Model October 2000
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.
o dontCare(3): Do them -- I don't care about the order.
When error / event reporting is addressed for the Policy Framework,
suitable codes will be defined for reporting that a set of actions could
not be performed in an order specified as mandatory (and thus were not
performed at all), that a set of actions could not be performed in a
recommended order (and moreover could not be performed in any order), or
that a set of actions could not be performed in a recommended order (but
were performed in a different order). The property definition is as
follows:
NAME SequencedActions
DESCRIPTION An enumeration indicating how to interpret the action
ordering indicated via the PolicyActionInPolicyRule
aggregation.
SYNTAX uint16
VALUES mandatory(1), recommended(2), dontCare(3)
DEFAULT VALUE dontCare(3)
6.3.7. The Multi-valued Property "PolicyRoles"
This property represents the roles and role combinations associated with
a policy rule. Each value represents one role combination. Since this
is a multi-valued property, more than one role combination can be
associated with a single policy rule. Each value is a string of the form
<RoleName>[&&<RoleName>]*
where the individual role names appear in alphabetical order (according
to the collating sequence for UCS-2). The property definition is as
follows:
NAME PolicyRoles
DESCRIPTION A set of strings representing the roles and role
combinations associated with a policy rule. Each
value represents one role combination.
SYNTAX string
6.4. The Abstract Class "PolicyCondition"
The purpose of a policy condition is to determine whether or not the set
of actions (aggregated in the PolicyRule that the condition applies to)
should be executed or not. For the purposes of the Policy Core
Information Model, all that matters about an individual PolicyCondition
is that it evaluates to TRUE or FALSE. (The individual PolicyConditions
associated with a PolicyRule are combined to form a compound expression
in either DNF or CNF, but this is accomplished via the ConditionListType
property, discussed above, and by the properties of the
Moore, et al. Expires: Oct 2000 + 6 months [Page 30]
Internet Draft Policy Core Information Model October 2000
PolicyConditionInPolicyRule aggregation, introduced above and discussed
further in Section 7.6 below.) A logical structure within an individual
PolicyCondition may also be introduced, but this would have to be done in
a subclass of PolicyCondition.
Because it is general, the PolicyCondition class does not itself contain
any "real" conditions. These will be represented by properties of the
domain-specific subclasses of PolicyCondition.
+---------------------------------------------------------------+
| Policy Conditions in DNF |
| +-------------------------+ +-----------------------+ |
| | AND list | | AND list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ORed | +-----------------+ | |
| | ... | | ... | |
| | ANDed | | ANDed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 7. Overview of Policy Conditions in DNF
This figure illustrates that when policy conditions are in DNF, there are
one or more sets of conditions that are ANDed together to form AND lists.
An AND list evaluates to TRUE if and only if all of its constituent
conditions evaluate to TRUE. The overall condition then evaluates to
TRUE if and only if at least one of its constituent AND lists evaluates
to TRUE.
Moore, et al. Expires: Oct 2000 + 6 months [Page 31]
Internet Draft Policy Core Information Model October 2000
+---------------------------------------------------------------+
| Policy Conditions in CNF |
| +-------------------------+ +-----------------------+ |
| | OR list | | OR list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ANDed | +-----------------+ | |
| | ... | | ... | |
| | ORed | | ORed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 8. Overview of Policy Conditions in CNF
In this figure, the policy conditions are in CNF. Consequently, there
are one or more OR lists, each of which evaluates to TRUE if and only if
at least one of its constituent conditions evaluates to TRUE. The
overall condition then evaluates to TRUE if and only if ALL of its
constituent OR lists evaluate to TRUE.
The class definition of PolicyCondition is as follows:
NAME PolicyCondition
DESCRIPTION A class representing a rule-specific or reusable
policy condition to be evaluated in conjunction with a
policy rule.
DERIVED FROM Policy
ABSTRACT TRUE
PROPERTIES NONE
No properties are defined for this class since it inherits all its
properties from Policy. The class exists as an abstract superclass for
domain-specific policy conditions, defined in subclasses. In an
implementation, various key/identification properties MUST be defined for
the class or its instantiable subclasses. The keys for a native CIM
implementation are defined in Appendix A, Section 14.2. Keys for an LDAP
implementation are defined in the LDAP mapping of this information model
[11].
When identifying and using the PolicyCondition class, it is necessary to
remember that a condition can be rule-specific or reusable. This was
discussed above in Section 5.1. The distinction between the two types of
policy conditions lies in the associations in which an instance can
participate, and in how the different instances are named. Conceptually,
a reusable policy condition resides in a policy repository, and is named
Moore, et al. Expires: Oct 2000 + 6 months [Page 32]
Internet Draft Policy Core Information Model October 2000
within the scope of that repository. On the other hand, a rule-specific
policy condition is, as the name suggests, named within the scope of the
single policy rule to which it is related.
The distinction between rule-specific and reusable PolicyConditions
affects the CIM naming, defined in Appendix A, and the LDAP mapping [11].
6.5. The Class "PolicyTimePeriodCondition"
This class provides a means of representing the time periods during which
a policy rule is valid, i.e., active. At all times that fall outside
these time periods, the policy rule has no effect. A policy rule is
treated as valid at all times if it does not specify a
PolicyTimePeriodCondition.
In some cases a PDP may need to perform certain setup / cleanup actions
when a policy rule becomes active / inactive. For example, sessions that
were established while a policy 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
policy rule would just be to prevent the establishment of new sessions.
Setup / cleanup behaviors on validity period transitions are not
currently addressed by the PCIM, and must be specified in 'guideline'
documents, or via subclasses of PolicyRule, PolicyTimePeriodCondition or
other concrete subclasses of 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 subclass.
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.
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 represent the following time
periods:
Moore, et al. Expires: Oct 2000 + 6 months [Page 33]
Internet Draft Policy Core Information Model October 2000
Friday, March 5, 2000, from 0800 through 1600;
Friday, March 12, 2000, from 0800 through 1600;
Friday, March 19, 2000, from 0800 through 1600;
Friday, March 26, 2000, from 0800 through 1600;
Friday, April 2, 2000, from 0800 through 1600;
Friday, April 9, 2000, from 0800 through 1600;
Friday, April 16, 2000, from 0800 through 1600;
Friday, April 23, 2000, from 0800 through 1600;
Friday, April 30, 2000, from 0800 through 1600.
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 we apply this "missing
property" rule to its fullest, we see that there is a second way to
indicate that a policy rule is always enabled: have it point to an
instance of PolicyTimePeriodCondition whose only properties are its
naming properties.
The property LocalOrUtcTime indicates whether the times represented in
the other five time-related properties of an instance of
PolicyTimePeriodCondition are to be interpreted as local times for the
location where a policy rule is being applied, or as UTC times.
The class definition is as follows.
NAME PolicyTimePeriodCondition
DESCRIPTION A class that provides the capability of enabling /
disabling a policy rule according to a pre-determined
schedule.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES TimePeriod
MonthOfYearMask
DayOfMonthMask
DayOfWeekMask
TimeOfDayMask
LocalOrUtcTime
6.5.1. The Property "TimePeriod"
This property identifies an overall range of calendar dates and times
over which a policy rule is valid. It reuses the format for an explicit
time period defined in RFC 2445 (reference [10]): a string representing a
starting 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
Moore, et al. Expires: Oct 2000 + 6 months [Page 34]
Internet Draft Policy Core Information Model October 2000
first. Date/times are expressed as substrings of the form
"yyyymmddThhmmss". For example:
20000101T080000/20000131T120000
January 1, 2000, 0800 through January 31, 2000, noon
There are also two special cases in which one of the date/time strings is
replaced with a special string defined in RFC 2445.
o If the first date/time is replaced with the string "THISANDPRIOR",
then the property indicates that a policy rule is valid [from now]
until the date/time that appears after the '/'.
o If the second date/time is replaced with the string "THISANDFUTURE",
then the property indicates that a policy rule becomes valid on the
date/time that appears before the '/', and remains valid from that
point on.
Note that RFC 2445 does not use these two strings in connection with
explicit time periods. Thus the PCIM is combining two elements from RFC
2445 that are not combined in the RFC itself.
The property definition is as follows:
NAME TimePeriod
DESCRIPTION The range of calendar dates on which a policy rule is
valid.
SYNTAX string
FORMAT yyyymmddThhmmss/yyyymmddThhmmss, where the first
date/time may be replaced with the string
"THISANDPRIOR" or the second date/time may be replaced
with the string "THISANDFUTURE"
6.5.2. The Property "MonthOfYearMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property, by explicitly
specifying the months when the policy is valid. These properties work
together, with the TimePeriod used to specify the overall time period
during which the policy might be valid, and the MonthOfYearMask used to
pick out the specific months within that time period when the policy is
valid.
This property is formatted as an octet string of size 2, 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. The value X'08
30', for example, indicates that a policy rule is valid only in the
months May, November, and December.
Moore, et al. Expires: Oct 2000 + 6 months [Page 35]
Internet Draft Policy Core Information Model October 2000
See section 5.4 for details of how CIM represents a single-valued octet
string property such as this one. (Basically, CIM prepends a 4-octet
length to the octet string.)
If this property is omitted, then the policy rule is treated as valid for
all twelve months. The property definition is as follows:
NAME MonthOfYearMask
DESCRIPTION A mask identifying the months of the year in which a
policy rule is valid.
SYNTAX octet string
FORMAT X'hh h0'
6.5.3. The Property "DayOfMonthMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property, by explicitly
specifying the days of the month when the policy is valid. These
properties work together, with the TimePeriod used to specify the overall
time period during which the policy might be valid, and the
DayOfMonthMask used to pick out the specific days of the month within
that time period when the policy is valid.
This property is formatted as an octet string of size 8, 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.
The value X'80 00 00 01 00 00 00 00', for example, indicates that a
policy rule is valid on the first and last days of the month.
For months with fewer than 31 days, the digits corresponding to days that
the months do not have (counting in both directions) are ignored.
The encoding of the 62 significant bits in the octet string matches that
used for the schedDay object in the DISMAN-SCHEDULE-MIB. See reference
[8] for more details on this object.
See section 5.4 for details of how CIM represents a single-valued octet
string property such as this one. (Basically, CIM prepends a 4-octet
length to the octet string.)
The property definition is as follows:
NAME DayOfMonthMask
DESCRIPTION A mask identifying the days of the month on which a
policy rule is valid.
SYNTAX octet string
FORMAT X'hh hh hh hh hh hh hh hh'
Moore, et al. Expires: Oct 2000 + 6 months [Page 36]
Internet Draft Policy Core Information Model October 2000
6.5.4. The Property "DayOfWeekMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property by explicitly
specifying the days of the week when the policy is valid. These
properties work together, with the TimePeriod used to specify the overall
time period when the policy might be valid, and the DayOfWeekMask used to
pick out the specific days of the week in that time period when the
policy is valid.
This property is formatted as an octet string of size 1, 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.
The value X'7C', for example, indicates that a policy rule is valid
Monday through Friday.
See section 5.4 for details of how CIM represents a single-valued octet
string property such as this one. (Basically, CIM prepends a 4-octet
length to the octet string.)
The property definition is as follows:
NAME DayOfWeekMask
DESCRIPTION A mask identifying the days of the week on which a
policy rule is valid.
SYNTAX octet string
FORMAT B'bbbb bbb0'
6.5.5. The Property "TimeOfDayMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property by explicitly
specifying a range of times in a day the policy is valid for. These
properties work together, with the TimePeriod used to specify the overall
time period that the policy is valid for, and the TimeOfDayMask used to
pick out which range of time periods in a given day of that time period
the policy is valid for.
This property is formatted in the style of RFC 2445 [10]: 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".
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
Moore, et al. Expires: Oct 2000 + 6 months [Page 37]
Internet Draft Policy Core Information Model October 2000
"T210000/T080000" identifies the range from 2100 until 0800 of the
following day.
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:
From midnight Sunday until 0800 Monday;
From 2100 Monday until 0800 Tuesday;
From 2100 Tuesday until 23:59:59 Tuesday.
The property definition is as follows:
NAME TimeOfDayMask
DESCRIPTION The range of times at which a policy rule is valid. If
the second time is earlier than the first, then the
interval spans midnight.
SYNTAX string
FORMAT Thhmmss/Thhmmss
6.5.6. The Property "LocalOrUtcTime"
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.
The property definition is as follows:
NAME LocalOrUtcTime
DESCRIPTION An indication of whether the other times in this
instance represent local times or UTC times.
SYNTAX uint16
VALUES localTime(1), utcTime(2)
DEFAULT VALUE utcTime(2)
6.6. The Class "VendorPolicyCondition"
The purpose of this class is to provide a general extension mechanism for
representing policy conditions 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.
Moore, et al. Expires: Oct 2000 + 6 months [Page 38]
Internet Draft Policy Core Information Model October 2000
As its name suggests, this class is intended for vendor-specific
extensions to the Policy Core Information Model. Standardized extensions
are not expected to use this class.
The class definition is as follows:
NAME VendorPolicyCondition
DESCRIPTION A class that defines a registered means to describe a
policy condition.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES Constraint[ ]
ConstraintEncoding
6.6.1. The Multi-valued Property "Constraint"
This property provides a general extension mechanism for representing
policy conditions 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.
See Section 5.4 for a description of how CIM encodes an array of octet
strings like this one.
A policy decision point can readily determine whether it supports the
values stored in an instance of Constraint by checking the OID value from
ConstraintEncoding against the set of OIDs it recognizes. The action for
the policy decision point to take in case it does not recognize the
format of this data could itself be modeled as a policy rule, governing
the behavior of the policy decision point.
The property is defined as follows:
NAME Constraint
DESCRIPTION Extension mechanism for representing constraints that
have not been modeled as specific properties. The
format of the values is identified by the OID stored
in the property ConstraintEncoding.
SYNTAX octet string
6.6.2. The Property "ConstraintEncoding"
This property identifies the encoding and semantics of the Constraint
property values in this instance. The value of this property is a single
string, representing a single OID.
The property is defined as follows:
NAME ConstraintEncoding
Moore, et al. Expires: Oct 2000 + 6 months [Page 39]
Internet Draft Policy Core Information Model October 2000
DESCRIPTION An OID encoded as a string, identifying the format and
semantics for this instance's Constraint property.
The value is a dotted sequence of decimal digits (for
example, "1.2.100.200") representing the arcs of the
OID. The characters in the string are the UCS-2
characters corresponding to the US ASCII encodings of
the numeric characters and the period.
SYNTAX string
6.7. The Abstract Class "PolicyAction"
The purpose of a policy action is to execute one or more operations that
will affect network traffic and/or systems, devices, etc. in order to
achieve a desired state. This (new) state provides one or more (new)
behaviors. A policy action ordinarily changes the configuration of one
or more elements.
A PolicyRule contains one or more policy actions. A policy administrator
can assign an order to the actions associated with a PolicyRule, complete
with an indication of whether the indicated order is mandatory,
recommended, or of no significance. Ordering of the actions associated
with a PolicyRule is accomplished via a property in the
PolicyActionInPolicyRule aggregation.
The actions associated with a PolicyRule are executed if and only if the
overall condition(s) of the PolicyRule evaluates to TRUE.
The class definition of PolicyAction is as follows:
NAME PolicyAction
DESCRIPTION A class representing a rule-specific or reusable
policy action to be performed if the condition for a
policy rule evaluates to TRUE.
DERIVED FROM Policy
ABSTRACT TRUE
PROPERTIES NONE
No properties are defined for this class since it inherits all its
properties from Policy. The class exists as an abstract superclass for
domain-specific policy actions, defined in subclasses. In an
implementation, various key/identification properties MUST be defined for
the class or its instantiable subclasses. The keys for a native CIM
implementation are defined in Appendix A, Section 14.3. Keys for an LDAP
implementation are defined in the LDAP mapping of this information model
[11].
When identifying and using the PolicyAction class, it is necessary to
remember that an action can be rule-specific or reusable. This was
discussed above in Section 5.1. The distinction between the two types of
policy actions lies in the associations in which an instance can
Moore, et al. Expires: Oct 2000 + 6 months [Page 40]
Internet Draft Policy Core Information Model October 2000
participate, and in how the different instances are named. Conceptually,
a reusable policy action resides in a policy repository, and is named
within the scope of that repository. On the other hand, a rule-specific
policy action is named within the scope of the single policy rule to
which it is related.
The distinction between rule-specific and reusable PolicyActions affects
the CIM naming, defined in Appendix A, and the LDAP mapping [11].
6.8. The Class "VendorPolicyAction"
The purpose of this class is to provide a general extension mechanism for
representing policy actions 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.
As its name suggests, this class is intended for vendor-specific
extensions to the Policy Core Information Model. Standardized extensions
are not expected to use this class.
The class definition is as follows:
NAME VendorPolicyAction
DESCRIPTION A class that defines a registered means to describe a
policy action.
DERIVED FROM PolicyAction
ABSTRACT FALSE
PROPERTIES ActionData[ ]
ActionEncoding
6.8.1. The Multi-valued Property "ActionData"
This property provides a general extension mechanism for representing
policy actions 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. See Section 5.4 for a
discussion of how CIM encodes an array of octet strings like this one.
A policy decision point can readily determine whether it supports the
values stored in an instance of ActionData by checking the OID value from
ActionEncoding against the set of OIDs it recognizes. The action for the
policy decision point to take in case it does not recognize the format of
this data could itself be modeled as a policy rule, governing the
behavior of the policy decision point.
The property is defined as follows:
NAME ActionData
DESCRIPTION Extension mechanism for representing actions that have
not been modeled as specific properties. The format of
Moore, et al. Expires: Oct 2000 + 6 months [Page 41]
Internet Draft Policy Core Information Model October 2000
the values is identified by the OID stored in the
property ActionEncoding.
SYNTAX octet string
6.8.2. The Property "ActionEncoding"
This property identifies the encoding and semantics of the ActionData
property values in this instance. The value of this property is a single
string, representing a single OID.
The property is defined as follows:
NAME ActionEncoding
DESCRIPTION An OID encoded as a string, identifying the format and
semantics for this instance's ActionData property.
The value is a dotted sequence of decimal digits (for
example, "1.2.100.200") representing the arcs of the
OID. The characters in the string are the UCS-2
characters corresponding to the US ASCII encodings of
the numeric characters and the period.
SYNTAX string
6.9. The Class "PolicyRepository"
The class definition of PolicyRepository is as follows:
NAME PolicyRepository
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 number of unique
associations.
DERIVED FROM AdminDomain
ABSTRACT FALSE
7. Association and Aggregation Definitions
The first two subsections of this section introduce associations and
aggregations as they are used in CIM. The remaining subsections present
the class definitions for the associations and aggregations that are part
of the Policy Core Information Model.
7.1. Associations
An association is a CIM construct representing a relationship between two
(or theoretically more) objects. It is modeled as a class containing
Moore, et al. Expires: Oct 2000 + 6 months [Page 42]
Internet Draft Policy Core Information Model October 2000
typically two object references. Associations can be defined between
classes without affecting any of the related classes. That is, addition
of an association does not affect the interface of the related classes.
7.2. Aggregations
An aggregation is a strong form of an association, which usually
represents a "whole-part" or a "collection" relationship. For example,
CIM uses an aggregation to represent the containment relationship between
a system and the components that make up the system. Aggregation as a
"whole-part" relationship often implies, but does not require, that the
aggregated objects have mutual dependencies.
7.3. The Abstract Aggregation "PolicyComponent
This abstract aggregation defines two object references that will be
overridden in each of five subclasses, to become references to the
concrete policy classes PolicyGroup, PolicyRule, PolicyCondition,
PolicyAction, and PolicyTimePeriodCondition. The value of the abstract
superclass is to convey that all five subclasses have the same "whole-
part" semantics, and for ease of query to locate all "components" of a
PolicyGroup or PolicyRule.
The class definition for the aggregation is as follows:
NAME PolicyComponent
DESCRIPTION A generic aggregation used to establish 'part of'
relationships between the subclasses of Policy. For
example, the PolicyConditionInPolicyRule aggregation
defines that PolicyConditions are part of a
PolicyRule.
ABSTRACT TRUE
PROPERTIES GroupComponent[ref Policy[0..n]]
PartComponent[ref Policy[0..n]]
7.4. The Aggregation "PolicyGroupInPolicyGroup"
The PolicyGroupInPolicyGroup aggregation enables policy groups to be
nested. This is critical for scalability and manageability, as it
enables complex policies to be constructed from multiple simpler policies
for administrative convenience. For example, a policy group representing
policies for the US might have nested within it policy groups for the
Eastern and Western US.
A PolicyGroup may aggregate other PolicyGroups via this aggregation, or
it may aggregate PolicyRules via the PolicyRuleInPolicyGroup aggregation.
Note that it is assumed that this aggregation is used to form directed
acyclic graphs and NOT ring structures.The class definition for the
aggregation is as follows:
NAME PolicyGroupInPolicyGroup
Moore, et al. Expires: Oct 2000 + 6 months [Page 43]
Internet Draft Policy Core Information Model October 2000
DESCRIPTION A class representing the aggregation of PolicyGroups
by a higher-level PolicyGroup.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyGroup[0..n]]
PartComponent[ref PolicyGroup[0..n]]
7.4.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyGroup that contains one or more other
PolicyGroups. Note that for any single instance of the aggregation class
PolicyGroupInPolicyGroup, this property (like all Reference properties)
is single-valued. The [0..n] cardinality indicates that there may be 0,
1, or more than one PolicyGroups that contain any given PolicyGroup.
7.4.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyGroup contained by one or more other
PolicyGroups. Note that for any single instance of the aggregation class
PolicyGroupInPolicyGroup, this property (like all Reference properties)
is single-valued. The [0..n] cardinality indicates that a given
PolicyGroup may contain 0, 1, or more than one other PolicyGroups.
7.5. The Aggregation "PolicyRuleInPolicyGroup"
A policy group may aggregate one or more policy rules, via the
PolicyRuleInPolicyGroup aggregation. Grouping of policy rules into a
policy group is again for administrative convenience; a policy rule may
also be used by itself, without belonging to a policy group.
A PolicyGroup may aggregate PolicyRules via this aggregation, or it may
aggregate other PolicyGroups via the PolicyGroupInPolicyGroup
aggregation.
The class definition for the aggregation is as follows:
NAME PolicyRuleInPolicyGroup
DESCRIPTION A class representing the aggregation of PolicyRules by
a PolicyGroup.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyGroup[0..n]]
PartComponent[ref PolicyRule[0..n]]
7.5.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyGroup that contains one or more
PolicyRules. Note that for any single instance of the aggregation class
PolicyRuleInPolicyGroup, this property (like all Reference properties) is
Moore, et al. Expires: Oct 2000 + 6 months [Page 44]
Internet Draft Policy Core Information Model October 2000
single-valued. The [0..n] cardinality indicates that there may be 0, 1,
or more than one PolicyGroups that contain any given PolicyRule.
7.5.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyRule contained by one or more
PolicyGroups. Note that for any single instance of the aggregation class
PolicyRuleInPolicyGroup, this property (like all Reference properties) is
single-valued. The [0..n] cardinality indicates that a given PolicyGroup
may contain 0, 1, or more than one PolicyRules.
7.6. The Aggregation "PolicyConditionInPolicyRule"
A policy rule aggregates zero or more instances of the PolicyCondition
class, via the PolicyConditionInPolicyRule association. A policy rule
that aggregates zero policy conditions must indicate in its class
definition what "triggers" the performance of its actions. In short, it
must describe its implicit PolicyConditions, since none are explicitly
associated. For example, there might be a subclass of PolicyRule named
"HttpPolicyRule", where the class definition assumes that the condition,
"If HTTP traffic," is true before the rule's actions would be performed.
There is no need to formalize and instantiate this condition, since it is
obvious in the semantics of the PolicyRule.
The conditions aggregated by a policy rule 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 conditions
in these lists may be negated. The property ConditionListType (in
PolicyRule) specifies which of these two grouping schemes applies to a
particular PolicyRule. The conditions are used to determine whether to
perform the actions associated with the PolicyRule.
One or more policy time periods may be among the conditions associated
with a policy rule via the PolicyConditionInPolicyRule association. In
this case, the time periods are simply additional conditions to be
evaluated along with any other conditions specified for the rule.
The class definition for the aggregation is as follows:
NAME PolicyConditionInPolicyRule
DESCRIPTION A class representing the aggregation of
PolicyConditions by a PolicyRule.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyCondition[0..n]]
GroupNumber
ConditionNegated
Moore, et al. Expires: Oct 2000 + 6 months [Page 45]
Internet Draft Policy Core Information Model October 2000
7.6.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyRule that contains one or more
PolicyConditions. Note that for any single instance of the aggregation
class PolicyConditionInPolicyRule, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, or more than one PolicyRules that contain any given
PolicyCondition.
7.6.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyCondition contained by one or more
PolicyRules. Note that for any single instance of the aggregation class
PolicyConditionInPolicyRule, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRule may contain 0, 1, or more than one PolicyConditions.
7.6.3. The Property "GroupNumber"
This property contains an integer identifying the group to which the
condition referenced by the PartComponent property is assigned in forming
the overall conditional expression for the policy rule identified by the
GroupComponent reference.
The property is defined as follows:
NAME GroupNumber
DESCRIPTION Unsigned integer indicating the group to which the
condition identified by the PartComponent property is
to be assigned.
SYNTAX uint16
DEFAULT 0
7.6.4. The Property "ConditionNegated"
This property is a boolean, indicating whether the condition referenced
by the PartComponent property is negated in forming the overall
conditional expression for the policy rule identified by the
GroupComponent reference.
The property is defined as follows:
NAME ConditionNegated
DESCRIPTION Indication of whether the condition identified by the
PartComponent property is negated. (TRUE indicates
that the condition is negated, FALSE indicates that it
is not negated.)
SYNTAX boolean
DEFAULT FALSE
Moore, et al. Expires: Oct 2000 + 6 months [Page 46]
Internet Draft Policy Core Information Model October 2000
7.7. The Aggregation "PolicyRuleValidityPeriod"
A different relationship between a policy rule and a policy time period
(than PolicyConditionInPolicyRule) is represented by the
PolicyRuleValidityPeriod aggregation. The latter describes scheduled
activation and deactivation of the policy rule.
If a policy rule 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 time periods are ORed
to determine whether the rule is active.) A policy time period may be
aggregated by multiple policy rules. A rule that does not point to a
policy time period via this aggregation is, from the point of view of
scheduling, always active. It may, however, be inactive for other
reasons.
Time periods are a general concept that can be used in other
applications. However, they are mentioned explicitly here in this
specification since they are frequently used in policy applications.
The class definition for the aggregation is as follows:
NAME PolicyRuleValidityPeriod
DESCRIPTION A class representing the aggregation of
PolicyTimePeriodConditions by a PolicyRule.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyTimePeriodCondition[0..n]]
7.7.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyRule that contains one or more
PolicyTimePeriodConditions. Note that for any single instance of the
aggregation class PolicyRuleValidityPeriod, this property (like all
Reference properties) is single-valued. The [0..n] cardinality indicates
that there may be 0, 1, or more than one PolicyRules that contain any
given PolicyTimePeriodCondition.
7.7.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyTimePeriodCondition contained by one or
more PolicyRules. Note that for any single instance of the aggregation
class PolicyRuleValidityPeriod, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRule may contain 0, 1, or more than one
PolicyTimePeriodConditions.
Moore, et al. Expires: Oct 2000 + 6 months [Page 47]
Internet Draft Policy Core Information Model October 2000
7.8. The Aggregation "PolicyActionInPolicyRule"
A policy rule may aggregate zero or more policy actions. A policy rule
that aggregates zero policy actions must indicate in its class definition
what actions are taken when the rule's conditions evaluate to TRUE. In
short, it must describe its implicit PolicyActions, since none are
explicitly associated. For example, there might be a subclass of
PolicyRule representing a Diffserv absolute dropper, where the subclass
itself indicates the action to be taken. There is no need to formalize
and instantiate this action, since it is obvious in the semantics of the
PolicyRule.
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.
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.
The class definition for the aggregation is as follows:
NAME PolicyActionInPolicyRule
DESCRIPTION A class representing the aggregation of PolicyActions
by a PolicyCondition.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyAction[0..n]]
ActionOrder
7.8.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyRule that contains one or more
PolicyActions. Note that for any single instance of the aggregation
class PolicyActionInPolicyRule, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, or more than one PolicyRules that contain any given
PolicyAction.
7.8.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to become
an object reference to a PolicyAction contained by one or more
PolicyRules. Note that for any single instance of the aggregation class
PolicyActionInPolicyRule, this property (like all Reference properties)
Moore, et al. Expires: Oct 2000 + 6 months [Page 48]
Internet Draft Policy Core Information Model October 2000
is single-valued. The [0..n] cardinality indicates that a given
PolicyRule may contain 0, 1, or more than one PolicyActions.
7.8.3. The Property "ActionOrder"
This property provides an unsigned integer 'n' that indicates the
relative position of an action in the sequence of actions associated with
a policy rule. 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 actions 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.
A series of examples will make ordering of actions clearer:
o If all actions have the same sequence number, regardless of whether it
is '0' or non-zero, any order is acceptable.
o The values
1:ACTION A
2:ACTION B
1:ACTION C
3:ACTION D
indicate two acceptable orders: A,C,B,D or C,A,B,D, since A and C can
be performed in either order, but only at the '1' position.
o The values
0:ACTION A
2:ACTION B
3:ACTION C
3:ACTION D
require that B,C, and D occur either as B,C,D or as B,D,C. Action A
may appear at any point relative to B,C, and D. Thus the complete set
of acceptable orders is: A,B,C,D; B,A,C,D; B,C,A,D; B,C,D,A; A,B,D,C;
B,A,D,C; B,D,A,C; B,D,C,A.
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.
The property is defined as follows:
NAME ActionOrder
DESCRIPTION Unsigned integer indicating the relative position of
an action in the sequence of actions aggregated by a
policy rule.
SYNTAX uint16
Moore, et al. Expires: Oct 2000 + 6 months [Page 49]
Internet Draft Policy Core Information Model October 2000
7.9. The Abstract Association "PolicyInSystem"
This abstract association inherits two object references from a higher-
level CIM association class, Dependency. It overrides these object
references to make them references to instances of the classes System and
Policy. Subclasses of PolicyInSystem then override these object
references again, to make them references to concrete policy classes.
The value of the abstract superclass is to convey that all subclasses
have the same "dependency" semantics, and for ease of query to locate all
policy "dependencies" on a System. These dependencies are related to
scoping or hosting of the Policy.
The class definition for the association is as follows:
NAME PolicyInSystem
DESCRIPTION A generic association used to establish dependency
relationships between Policies and the Systems that
host them.
DERIVED FROM Dependency
ABSTRACT TRUE
PROPERTIES Antecedent[ref System[0..1]]
Dependent[ref Policy[0..n]]
7.10. The Weak Association "PolicyGroupInSystem"
This association links a PolicyGroup to the System in whose scope the
PolicyGroup is defined.
The class definition for the association is as follows:
NAME PolicyGroupInSystem
DESCRIPTION A class representing the fact that a PolicyGroup is
defined within the scope of a System.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref System[1..1]]
Dependent[ref PolicyGroup[weak]]
7.10.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to
restrict its cardinality to [1..1]. It serves as an object reference to
a System that provides a scope for one or more PolicyGroups. Since this
is a weak association, the cardinality for this object reference is
always 1, that is, a PolicyGroup is always defined within the scope of
exactly one System.
Moore, et al. Expires: Oct 2000 + 6 months [Page 50]
Internet Draft Policy Core Information Model October 2000
7.10.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyGroup defined within the scope of a
System. Note that for any single instance of the association class
PolicyGroupInSystem, this property (like all Reference properties) is
single-valued. The [0..n] cardinality indicates that a given System may
have 0, 1, or more than one PolicyGroups defined within its scope.
7.11. The Weak Association "PolicyRuleInSystem"
Regardless of whether it belongs to a PolicyGroup (or to multiple
PolicyGroups), a PolicyRule is itself defined within the scope of a
System. This association links a PolicyRule to the System in whose scope
the PolicyRule is defined.
The class definition for the association is as follows:
NAME PolicyRuleInSystem
DESCRIPTION A class representing the fact that a PolicyRule is
defined within the scope of a System.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref System[1..1]]
Dependent[ref PolicyRule[weak]]
7.11.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to
restrict its cardinality to [1..1]. It serves as an object reference to
a System that provides a scope for one or more PolicyRules. Since this
is a weak association, the cardinality for this object reference is
always 1, that is, a PolicyRule is always defined within the scope of
exactly one System.
7.11.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyRule defined within the scope of a System.
Note that for any single instance of the association class
PolicyRuleInSystem, this property (like all Reference properties) is
single-valued. The [0..n] cardinality indicates that a given System may
have 0, 1, or more than one PolicyRules defined within its scope.
7.12. The Association "PolicyConditionInPolicyRepository"
A reusable policy condition is always related to a single
PolicyRepository, via the PolicyConditionInPolicyRepository association.
This is not true for all PolicyConditions, however. An instance of
PolicyCondition that represents a rule-specific condition is not related
to any policy repository via this association.
Moore, et al. Expires: Oct 2000 + 6 months [Page 51]
Internet Draft Policy Core Information Model October 2000
The class definition for the association is as follows:
NAME PolicyConditionInPolicyRepository
DESCRIPTION A class representing the inclusion of a reusable
PolicyCondition in a PolicyRepository.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref PolicyRepository[0..1]]
Dependent[ref PolicyCondition[0..n]]
7.12.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyRepository containing 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.
7.12.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyCondition included in a PolicyRepository.
Note that for any single instance of the association class
PolicyConditionInPolicyRepository, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRepository may contain 0, 1, or more than one
PolicyConditions.
7.13. The Association "PolicyActionInPolicyRepository"
A reusable policy action is always related to a single PolicyRepository,
via the PolicyActionInPolicyRepository association. This is not true for
all PolicyActions, however. An instance of PolicyAction that represents
a rule-specific action is not related to any policy repository via this
association.
The class definition for the association is as follows:
NAME PolicyActionInPolicyRepository
DESCRIPTION A class representing the inclusion of a reusable
PolicyAction in a PolicyRepository.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref PolicyRepository[0..1]]
Dependent[ref PolicyAction[0..n]]
7.13.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyRepository containing one or more
Moore, et al. Expires: Oct 2000 + 6 months [Page 52]
Internet Draft Policy Core Information Model October 2000
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.
7.13.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to become
an object reference to a PolicyAction included in a PolicyRepository.
Note that for any single instance of the association class
PolicyActionInPolicyRepository, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRepository may contain 0, 1, or more than one PolicyActions.
7.14. The Aggregation "PolicyRepositoryInPolicyRepository"
The PolicyRepositoryInPolicyRepository aggregation enables policy
repositories to be nested. This derives from the higher level CIM
association, CIM_SystemComponent, describing that Systems contain other
ManagedSystemElements. This superclass could not be used for the other
Policy aggregations, since Policies are not ManagedSystemElements, but
ManagedElements. Note that it is assumed that this aggregation is used to
form directed acyclic graphs and NOT ring structures.
The class definition for the aggregation is as follows:
NAME PolicyRepositoryInPolicyRepository
DESCRIPTION A class representing the aggregation of
PolicyRepositories by a higher-level PolicyRepository.
DERIVED FROM SystemComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRepository[0..n]]
PartComponent[ref PolicyRepository[0..n]]
7.14.1. The Reference "GroupComponent"
This property is inherited from the CIM class SystemComponent, and
overridden to become an object reference to a PolicyRepository that
contains one or more other PolicyRepositories. Note that for any single
instance of the aggregation class PolicyRepositoryInPolicyRepository,
this property (like all Reference properties) is single-valued. The
[0..n] cardinality indicates that there may be 0, 1, or more than one
PolicyRepositories that contain any given PolicyRepository.
7.14.2. The Reference "PartComponent"
This property is inherited from the CIM class SystemComponent, and
overridden to become an object reference to a PolicyRepository contained
by one or more other PolicyRepositories. Note that for any single
instance of the aggregation class PolicyRepositoryInPolicyRepository,
this property (like all Reference properties) is single-valued. The
Moore, et al. Expires: Oct 2000 + 6 months [Page 53]
Internet Draft Policy Core Information Model October 2000
[0..n] cardinality indicates that a given PolicyRepository may contain 0,
1, or more than one other PolicyRepositories.
8. Intellectual Property
The IETF takes no position regarding the validity or scope of any
intellectual property or other rights that might be claimed to pertain to
the implementation or use of the technology described in this document or
the extent to which any license under such rights might or might not be
available; neither does it represent that it has made any effort to
identify any such rights. Information on the IETF's procedures with
respect to rights in standards-track and standards-related documentation
can be found in BCP-11.
Copies of claims of rights made available for publication and any
assurances of licenses to be made available, or the result of an attempt
made to obtain a general license or permission for the use of such
proprietary rights by implementers or users of this specification can be
obtained from the IETF Secretariat.
The IETF invites any interested party to bring to its attention any
copyrights, patents or patent applications, or other proprietary rights
which may cover technology that may be required to practice this
standard. Please address the information to the IETF Executive Director.
9. Acknowledgements
The Policy Core Information Model in this document is closely based on
the work of the DMTF's Service Level Agreements working group, so thanks
are due to the members of that working group. Several of
PolicyCondition.
Because it is general, the PolicyCondition class does not itself
contain any "real" conditions. These will be represented by
properties policy
classes in this model first appeared in early drafts on IPSec policy and
QoS policy. The authors of the domain-specific subclasses these drafts were Partha Bhattacharya, Rob
Adams, William Dixon, Roy Pereira, Raju Rajan, Jean-Christophe Martin,
Sanjay Kamat, Michael See, Rajiv Chaudhury, Dinesh Verma, George Powers,
and Raj Yavatkar. Some other elements of PolicyCondition.
+---------------------------------------------------------------+
| Policy Conditions the model originated in DNF |
| +-------------------------+ +-----------------------+ |
| | AND list | | AND list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ORed | +-----------------+ | |
| | ... | | ... | |
| | ANDed | | ANDed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 7. Overview work
done by Yoram Snir, Yoram Ramberg, and Ron Cohen. In addition, we would
like to thank Harald Alvestrand for conducting a thorough review of this
draft and providing many helpful suggestions, and Luis Sanchez and Russ
Mundy for their help with the document's Security Considerations.
10. Security Considerations
The Policy Conditions Core Information Model (PCIM) presented in DNF
This figure illustrates that when this document
provides an object-oriented model for describing policy information. It
provides a basic framework for describing the structure of policy conditions are
information, in DNF, there
are one or more sets of conditions that are ANDed together to a form AND
lists. An AND list evaluates to TRUE if and only if all of its
constituent conditions evaluate to TRUE. The overall condition then
evaluates to TRUE if and only if at least one independent of its constituent AND
lists evaluates any specific repository or access
protocol, for use by an operational system. PCIM is not intended to TRUE.
represent any particular system design or implementation, nor does it
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 29] 54]
Internet Draft Policy Core Information Model July October 2000
+---------------------------------------------------------------+
| Policy Conditions in CNF |
| +-------------------------+ +-----------------------+ |
| | OR list | | OR list | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | ... | | PolicyCondition | | |
| | +-------------------+ | ANDed | +-----------------+ | |
| | ... | | ... | |
| | ORed | | ORed | |
| | +-------------------+ | | +-----------------+ | |
| | | PolicyCondition | | | | PolicyCondition | | |
| | +-------------------+ | | +-----------------+ | |
| +-------------------------+ +-----------------------+ |
+---------------------------------------------------------------+
Figure 8. Overview
define a protocol, and as such it does not have any specific security
requirements.
However, it should also be noted that certain derivative documents, which
use PCIM as a base, will need to convey more specific security
considerations. In order to communicate the nature of Policy Conditions what will be
expected in CNF
In this figure, these follow-on derivative documents, it is necessary to
review the policy conditions are reasons that PCIM, as defined in CNF. Consequently, there
are one or more OR lists, each this document, is neither
implementable, nor representative of which evaluates to TRUE if any real-world system, as well as
the nature of the expected follow-on extensions and only
if at least one mappings.
There are three independent reasons that PCIM, as defined here, is
neither implementable nor representative of any real-world system:
1. Its classes are independent of any specific repository that uses
any specific access protocol. Therefore, its constituent conditions evaluates classes are designed
not to TRUE. The
overall condition then evaluates be implemented directly. PCIM should instead be viewed as a
schematic that directs how information should be represented,
independent of any specific model implementation constraints.
2. Its classes were designed to TRUE if be independent of any specific policy
domain. For example, DiffServ and only if ALL IPSec represent two different
policy domains. Each document which extends PCIM to one of its
constituent OR lists evaluate these
domains will derive subclasses from the classes and relationships
defined in PCIM, in order to TRUE.
The class definition represent extensions of PolicyCondition is as follows:
NAME PolicyCondition
DESCRIPTION A class representing a rule-specific or reusable
policy condition generic
model to cover specific technical domains.
3. It's an information model, which must be evaluated in conjunction
with mapped to a policy rule.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES NONE
No properties are defined for this class since specific data
model (native CIM schema, LDAP schema, MIB, whatever) before it inherits all its
properties from Policy. The class exists as an abstract superclass
for domain-specific policy conditions, defined can
be implemented. Derivative documents will map the extended
information models noted in subclasses. In an
implementation, various key/identification properties item 2, above, to specific types of
data model implementations.
Even though specific security requirements are not appropriate for PCIM,
specific security requirements MUST be defined for the class or its instantiable subclasses. The keys for each operational real-
world application of PCIM. Just as there will be a native
CIM implementation are defined in Appendix A, Section 14.2. Keys wide range of
operational, real-world systems using PCIM, there will also be a wide
range of security requirements for
an LDAP implementation these systems. Some operational,
real-world systems that are defined in the LDAP mapping of this
information model [11].
When identifying and deployed using the PolicyCondition class, it is necessary
to remember PCIM may have extensive
security requirements that impact nearly all classes and subclasses
utilized by such a condition can be rule-specific or reusable. This
was discussed above in Section 5.1. system, while other systems' security requirements
might have very little impact.
The distinction between derivative documents, discussed above, will create the two
types of policy conditions lies in context for
applying operational, real-world, system-level security requirements
against the associations in various models which an
instance can participate, and derive from PCIM.
For example, in how some real-world scenarios, the different instances are
named. Conceptually, a reusable policy condition resides in a policy
repository, and is named values associated with
certain properties, within certain instantiated classes, may represent
information associated with scarce, and/or costly (and therefore
valuable) resources. It may be the scope of case that repository. On these values must not be
disclosed to, or manipulated by, unauthorized parties. As long as the
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 30] 55]
Internet Draft Policy Core Information Model July October 2000
other hand, a rule-specific policy condition is, as the name suggests,
named within the scope of the single policy rule
derived model remains an information model (as opposed to which a data model),
it is
related.
The distinction between rule-specific and reusable PolicyConditions
affects not possible to discuss the CIM naming, defined in Appendix A, data model-specific tools and
mechanisms that are available for achieving the LDAP mapping
[11].
6.5. The Class "PolicyTimePeriodCondition"
This class provides authentication and
authorization implicit in a means requirement that restricts read and/or read-
write access to these values. Therefore, these mechanisms will need to
be discussed in each of representing the time periods during data models to which a policy rule is valid, i.e., active. At all times the derived information
models are mapped. If there are any general security requirements that fall
outside
can be identified and can be applied across multiple types of data
models, it would be appropriate to discuss those at the information model
level, rather than the data model level. In any case, any identified
security requirements that are not dealt with in the information model
document, MUST be dealt with in the derivative data model documents.
We can illustrate these time periods, points by extending the policy rule has no effect. example from Section 2.
A policy
rule is treated as valid at all times if it does not specify a
PolicyTimePeriodCondition.
In some cases a PDP may need to perform certain setup / cleanup
actions when a policy rule becomes active / inactive. For example,
sessions real-world system that were established while a policy rule was active might provides QoS Gold Service to John would likely
need to be taken down when provide at least the rule becomes inactive. In other cases,
however, such sessions might be left up: in this case, following security-related capabilities and
mechanisms (see [12] for definitions of security related terms):
o Data integrity for the information (e.g. property values and
instantiated relationships) that specify that John gets QoS Gold
Service, from the effect of
deactivating point(s) that the policy rule would just be to prevent information is entered into the
establishment of new sessions. Setup / cleanup behaviors on validity
period transitions are not currently addressed by
system to the PCIM, point(s) where network components actually provide
that Service.
o Authentication and must
be specified in 'guideline' documents, or via subclasses of
PolicyRule, PolicyTimePeriodCondition Authorization methods to ensure that only system
administrators (and not John or other concrete subclasses engineers) can remotely
administer components of
Policy. If such behaviors need the system.
o An Authentication method to be under insure that John receives Gold Service,
and the control other members of the policy
administrator, then a mechanism engineering group receive Bronze
Service.
These are one possible set of requirements associated with an example
real-world system which delivers Gold Service, and the appropriate place
to allow this control must also document these would be
specified in the subclass.
PolicyTimePeriodCondition is defined as a subclass some combination of PolicyCondition.
This is to allow the inclusion of time-based criteria in information model
and the AND/OR
condition definitions derivative data models for a PolicyRule.
Instances of this class may have up to five properties identifying
time periods at different levels. The values QoS Policy. Each of all the properties
present in an instance are ANDed together data models
would also need to determine the validity
period(s) for discuss how these requirements are satisfied, using
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 mechanisms typically available to such a time of day range data model, given the
particular technology or set of 0800 through 1600 would represent technologies which it may employ.
11. References
[1] Distributed Management Task Force, Inc., "DMTF Technologies: CIM
Standards û CIM Schema: Version 2.4", available via links on the
following time periods: DMTF web page: http://www.dmtf.org/spec/cim_schema_v24.html.
[2] Distributed Management Task Force, Inc., "Common Information Model
(CIM) Specification, version 2.2, June 1999. This document is
available on the following DMTF web page:
http://www.dmtf.org/spec/cims.html.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 31] 56]
Internet Draft Policy Core Information Model July October 2000
Friday, March 5, 2000, from 0800 through 1600;
Friday, March 12, 2000, from 0800 through 1600;
Friday, March 19, 2000, from 0800 through 1600;
Friday, March 26, 2000, from 0800 through 1600;
Friday, April 2, 2000, from 0800 through 1600;
Friday, April 9, 2000, from 0800 through 1600;
Friday, April 16, 2000, from 0800 through 1600;
Friday, April 23, 2000, from 0800 through 1600;
Friday, April 30, 2000, from 0800 through 1600.
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
[3] Bradner, S., "Key words for the instance implicitly includes a day-of-the-
month mask that selects all days of the month. If we apply this
"missing property" rule to its fullest, we see that there is a second
way to indicate that a policy rule is always enabled: have it point use in RFCs to
an instance of PolicyTimePeriodCondition whose only properties are its
naming properties.
The property LocalOrUtcTime indicates whether the times represented Indicate Requirement
Levels", BCP 14, RFC 2119, March 1997.
[4] Hovey, R., and S. Bradner, "The Organizations Involved in the other five time-related properties of an instance IETF
Standards Process", BCP 11, RFC 2028, October 1996.
[5] J. Strassner and S. Judd, "Directory-Enabled Networks", version 3.0c5
(August 1998). A PDF file is available at
http://www.murchiso.com/den/#denspec.
[6] J. Strassner, policy architecture BOF presentation, 42nd IETF Meeting,
Chicago, Illinois, October, 1998. Minutes of
PolicyTimePeriodCondition this BOF are to be interpreted as local times for available
at the
location where following location:
http://www.ietf.org/proceedings/98aug/index.html.
[7] Yergeau, F., "UTF-8, a policy rule is being applied, or as UTC times.
The class definition is as follows.
NAME PolicyTimePeriodCondition
DESCRIPTION A class that provides the capability transformation format of enabling /
disabling a policy rule according to a pre-
determined schedule.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES TimePeriod
MonthOfYearMask
DayOfMonthMask
DayOfWeekMask
TimeOfDayMask
LocalOrUtcTime
6.5.1. The Property "TimePeriod"
This property identifies an overall range ISO 10646", RFC 2279,
January 1998.
[8] Levi, D., and J. Schoenwaelder, "Definitions of calendar dates Managed Objects for
Scheduling Management Operations", RFC 2591, May 1999.
[9] R. Yavatkar and times
over which a policy rule is valid. It reuses the format D. Pendarakis, R. Guerin, "A Framework for an
explicit time period defined in Policy-
based Admission Control", RFC 2445 (reference [10]): a string
representing a starting date 2753, January 2000.
[10] Dawson, F., and time, in which the character 'T'
indicates the beginning of the time portion, followed by D. Stenerson, "Internet Calendaring and Scheduling
Core Object Specification (iCalendar)", RFC 2445, November 1998.
[11] Strassner, J., and E. Ellesson, B. Moore, R. Moats, "Policy Core LDAP
Schema", draft-ietf-policy-core-schema-07.txt, July 2000.
[12] Shirey, R., "Internet Security Glossary", RFC 2828, May 2000.
Note: the solidus
character '/', followed CIM 2.4 Schema specification is defined 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 following set of
MOF files, available from the form "yyyymmddThhmmss". For example: following URL:
http://www.dmtf.org/spec/CIM_Schema24/CIM_Schema24.zip
12. Authors' Addresses
Ed Ellesson
Tivoli Systems
Building 10, Office R2D39
3901 Miami Blvd.
Durham, NC 27703
Phone: +1 919-224-2111
Fax: +1 919-224-2540
E-mail: ed_ellesson@tivoli.com
Bob Moore
IBM Corporation, BRQA/502
4205 S. Miami Blvd.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 32] 57]
Internet Draft Policy Core Information Model July October 2000
20000101T080000/20000131T120000
January 1, 2000, 0800 through January 31, 2000, noon
There are also two special cases in which one of the date/time strings
is replaced with a special string defined in RFC 2445.
o If the first date/time is replaced with the string "THISANDPRIOR",
then the property indicates that a policy rule is valid [from now]
until the date/time that appears after the '/'.
o If the second date/time is replaced with the string
"THISANDFUTURE", then the property indicates that a policy rule
becomes valid on the date/time that appears before the '/', and
remains valid from that point on.
Note that RFC 2445 does not use these two strings in connection with
explicit time periods. Thus the PCIM is combining two elements from
RFC 2445 that are not combined in the RFC itself.
The property definition is as follows:
NAME TimePeriod
DESCRIPTION
Research Triangle Park, NC 27709
Phone: +1 919-254-4436
Fax: +1 919-254-6243
E-mail: remoore@us.ibm.com
John Strassner
Cisco Systems, Bldg 15
170 West Tasman Drive
San Jose, CA 95134
Phone: +1 408-527-1069
Fax: +1 408-527-6351
E-mail: johns@cisco.com
Andrea Westerinen
Cisco Systems
170 West Tasman Drive
San Jose, CA 95134
Phone: +1 408-853-8294
Fax: +1 408-527-6351
E-mail: andreaw@cisco.com
13. Full Copyright Statement
Copyright (C) The range Internet Society (2000). All Rights Reserved.
This document and translations of calendar dates on which a policy rule
is valid.
SYNTAX string
FORMAT yyyymmddThhmmss/yyyymmddThhmmss, where the first
date/time it may be replaced with the string
"THISANDPRIOR" copied and furnished to
others, and derivative works that comment on or the second date/time otherwise explain it or
assist in its implementation may be
replaced with the string "THISANDFUTURE"
6.5.2. The Property "MonthOfYearMask"
The purpose of this property is to refine the definition of the valid
time period that is defined by the TimePeriod property, by explicitly
specifying which months the policy is valid for. These properties
work together, with the TimePeriod used to specify the overall time
period that the policy is valid for, prepared, copied, published and the MonthOfYearMask used to
pick out which months
distributed, in whole or in part, without restriction of any kind,
provided that time period the policy is valid for.
This property is formatted as an octet string, structured above copyright notice and this paragraph are included
on all such copies and derivative works. However, this document itself
may not be modified in any way, such as follows:
o a 4-octet length field, indicating the length of by removing the entire octet
string; this field is always set copyright notice
or references to 0x00000006 the Internet Society or other Internet organizations,
except as needed for this property;
o a 2-octet field consisting of 12 bits identifying the 12 months purpose of developing Internet standards in
which case the year, beginning with January procedures for copyrights defined in the Internet
Standards process must be followed, or as required to translate it into
languages other than English.
The limited permissions granted above are perpetual and ending with December, followed will not be
revoked by 4 bits that are always set to '0'. For each month, the value
'1' indicates that the policy is valid for that month, Internet Society or its successors or assigns.
This document and the
value '0' indicates that it is not valid.
The value 0x000000060830, for example, indicates that a policy rule information contained herein is
valid only in the months May, November, provided on an "AS
IS" basis and December . THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK
FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
FITNESS FOR A PARTICULAR PURPOSE.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 33] 58]
Internet Draft Policy Core Information Model July October 2000
If this property is omitted, then the policy rule is treated as valid
for all twelve months. The property definition is as follows:
NAME MonthOfYearMask
DESCRIPTION A mask identifying the months of the year
14. Appendix A: Class Identification in which a policy rule is valid.
SYNTAX octet string
FORMAT 0x00000006XXX0
6.5.3. The Property "DayOfMonthMask"
The purpose of this property is to refine the definition of Native CIM Implementation
While the valid
time period that CommonName property is defined by the TimePeriod property, by explicitly
specifying which days of the month present in the policy abstract superclass
Policy, and is valid for. These
properties work together, with the TimePeriod used to specify the
overall time period that the policy thus available in all of its instantiable subclasses, CIM
does not use this property for naming instances. The following
subsections discuss how naming is valid for, and the
DayOfMonthMask used to pick out which days handled in a native CIM implementation
for each of the month instantiable classes in that time
period the policy is valid for.
This property Policy Core Information
Model.
Two things should be noted regarding CIM naming:
o When a CIM association is formatted as an octet string, structured specified as follows:
o "weak", this is a 4-octet length field, indicating statement
about naming scopes: an instance of the length class at the weak end of the entire octet
string; this field
association is always set to 0x0000000C for this property;
o named within the scope of an 8-octet field consisting instance of 31 bits identifying the days of class at
the
month counting from other end of the beginning, followed association. This is accomplished by 31 more bits
identifying the days propagation
of the month counting keys from the end, followed
by 2 bits that are always set instance of the scoping class to '0'. For each day, the value '1'
indicates that instance of the policy is valid for that day, and
weak class. Thus the value '0'
indicates that it is not valid.
The value 0x0000000C8000000100000000, for example, indicates that a
policy rule is valid on weak class has, via key propagation, all the first
keys from the scoping class, and last days it also has one or more additional
keys for distinguishing instances of the month.
For months with fewer than 31 days, weak class, within the digits corresponding to days
that
context of the months do not have (counting scoping class.
o All class names in both directions) CIM are ignored.
The encoding of limited to alphabetic and numeric
characters plus the 62 significant bits in underscore, with the octet string matches restriction that used for the schedDay object first
character cannot be numeric. Refer to Appendix F "Unicode Usage" in the DISMAN-SCHEDULE-MIB. See
reference [8] [2] for more details on this object.
The property definition is as follows:
NAME DayOfMonthMask
DESCRIPTION an exact specification of how CIM class names are
encoded in CIM strings.
14.1. Naming Instances of PolicyGroup and PolicyRule
A mask identifying policy group always exists in the days context of a system. In the month on which Policy
Core Information Model, this is captured by the weak aggregation
PolicyGroupInSystem between a PolicyGroup and a System. Note that System
serves as the base class for describing network devices and
administrative domains.
A policy rule also exists in the context of a system. In the Policy Core
Information Model, this is valid.
SYNTAX octet string
FORMAT 0x0000000CXXXXXXXXXXXXXXXX captured by the weak association
PolicyRuleInSystem between a PolicyRule and a System.
The following sections define the CIM keys for PolicyGroup and
PolicyRule.
14.1.1. PolicyGroup's CIM Keys
The CIM keys of the PolicyGroup class are:
o SystemCreationClassName (A CIM_System key, propagated due to the
weak association, PolicyGroupInSystem)
o SystemName (A CIM_System key, propagated due to the weak
association, PolicyGroupInSystem)
o CreationClassName
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 34] 59]
Internet Draft Policy Core Information Model July October 2000
6.5.4. The Property "DayOfWeekMask"
The purpose of this property is to refine the definition of the valid
time period that is
o PolicyGroupName
They are defined by the TimePeriod property by explicitly
specifying which days of the week the policy is valid for. These
properties work together, with the TimePeriod used to specify the
overall time period that the policy is valid for, and the
DayOfWeekMask used to pick out which days of the week in that time
period the policy is valid for.
This property is formatted as an octet string, structured Reference [1] as follows:
o a 4-octet length field, indicating the length of the entire octet
string; this field is always set to 0x00000005 for this property;
o a 1-octet field consisting of 7 bits identifying the 7 days of
NAME SystemCreationClassName
DESCRIPTION SystemCreationClassName represents the
week, beginning with Sunday and ending with Saturday, followed by 1
bit that is always set to '0'. For each day class name of
the week, the value
'1' indicates that CIM System object providing the policy is valid naming scope for that day, and
the value
'0' indicates that it is not valid.
The value 0x000000057C, for example, indicates that a policy rule is
valid Monday through Friday.
The property definition is as follows: instance of PolicyGroup.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME DayOfWeekMask SystemName
DESCRIPTION A mask identifying SystemName represent the days individual name of the week on which a
policy rule is valid.
SYNTAX octet string
FORMAT 0x00000005XX
6.5.5. The Property "TimeOfDayMask"
The purpose
particular System object, providing the naming scope
for the instance of this PolicyGroup.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION This property is set to refine the definition of "CIM_PolicyGroup", if the valid
time period that
PolicyGroup object is defined by the TimePeriod property by explicitly
specifying a range of times in a day the policy directly instantiated. Or, it
is valid for. These
properties work together, with the TimePeriod used equal to specify the
overall time period that the policy is valid for, and the
TimeOfDayMask used to pick out which range of time periods in a given
day class name of that time period the policy is valid for.
This property PolicyGroup subclass
that is formatted in the style instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyGroupName
DESCRIPTION The identifying name of RFC 2445 [10]: a time this policy group.
SYNTAX string beginning with the character 'T', followed by the solidus
character '/', followed by a second time string. [MaxLen 256]
QUALIFIER key
14.1.2. PolicyRule's CIM Keys
The first time
indicates the beginning CIM keys of the range, while the second time indicates PolicyRule class are:
o SystemCreationClassName (A CIM_System key, propagated due to the end. Times are expressed as substrings of
weak association PolicyRuleInSystem)
o SystemName (A CIM_System key, propagated due to the form "Thhmmss".
The second substring always identifies a later time than weak association
PolicyRuleInSystem)
o CreationClassName
o PolicyRuleName
SystemCreationClassName and SystemName work the first
substring. To allow same as defined for ranges that span midnight, however, the value
of
class PolicyGroup. See Section 14.1.1 for details.
The other two properties are defined in Reference [1] as follows:
NAME CreationClassName
DESCRIPTION This property is set to "CIM_PolicyRule", if the second string may be smaller than
PolicyRule object is directly instantiated. Or, it is
equal to the value class name of the first
substring. Thus, "T080000/T210000" identifies the range from 0800 PolicyRule subclass
that is instantiated.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 35] 60]
Internet Draft Policy Core Information Model July October 2000
until 2100, while "T210000/T080000" identifies the range from 2100
until 0800
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleName
DESCRIPTION The identifying name of the following day.
When a range spans midnight, it by definition includes parts this policy rule.
SYNTAX string [MaxLen 256]
QUALIFIER key
14.2. Naming Instances of two
successive days. When one PolicyCondition and Its Subclasses
The CIM keys of these days is also selected by either the MonthOfYearMask, DayOfMonthMask, and/or DayOfWeekMask, but PolicyCondition class are:
o SystemCreationClassName
o SystemName
o PolicyRuleCreationClassName
o PolicyRuleName
o CreationClassName
o PolicyConditionName
Note that none of the
other day keys are defined as propagated, although they
appear to fit this convention. The reason for this difference is not, then because
(as indicated in Sections 5.1 and 6.4) the policy PolicyCondition class 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, used
to represent both reusable and the day rule-specific conditions. This, in turn,
affects what associations are valid for an instance of week mask selects Monday PolicyCondition,
and Tuesday, then the policy is active during the following three
intervals:
From midnight Sunday until 0800 Monday;
From 2100 Monday until 0800 Tuesday;
From 2100 Tuesday until 23:59:59 Tuesday.
The property definition how that instance is as follows:
NAME TimeOfDayMask
DESCRIPTION The range named.
In an ideal world, an instance of times at which the PolicyCondition class would be
scoped either by its PolicyRepository (for a policy rule is valid.
If reusable condition) or by
its PolicyRule (for a rule-specific condition). However, CIM has the second time is earlier than
restriction that a given class can only be "weak" to one other class
(i.e., defined by one weak association).
To work within the first, then restrictions of CIM naming, it is necessary to
"simulate" weak associations between PolicyCondition and PolicyRule, and
between PolicyCondition and PolicyRepository, through a technique we'll
call manual key propagation. Strictly speaking, manual key propagation
isn't key propagation at all. But it has the interval spans midnight.
SYNTAX string
FORMAT Thhmmss/Thhmmss
6.5.6. The Property "LocalOrUtcTime"
This property indicates whether same effect as (true) key
propagation, so the times represented name fits.
Figure 9 illustrates how manual propagation works in the
TimePeriod property and in case of
PolicyCondition. (Note that only the various Mask key properties represent local
times or UTC times. There is no provision are shown for mixing each of local times
and UTC times:
the value of this property applies to all of classes.) In the other
time-related properties.
The property definition is as follows:
NAME LocalOrUtcTime
DESCRIPTION An indication of whether figure, the other times in this
instance represent local times or UTC times.
SYNTAX uint16
VALUES localTime(1), utcTime(2)
DEFAULT VALUE utcTime(2)
6.6. The Class "VendorPolicyCondition"
The purpose line composed of this 'I's indicates class is to provide a general extension mechanism
for representing policy conditions that have not been modeled with
specific properties. Instead,
inheritance, the one composed of 'P's indicates (true) key propagation
via the two properties Constraint weak aggregation PolicyRuleInSystem, and
ConstraintEncoding are used to define the content and format ones composed of the
condition, as explained below.
'M's indicate manual key propagation.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 36] 61]
Internet Draft Policy Core Information Model July October 2000
As its name suggests, this class is intended for vendor-specific
extensions to the Policy Core Information Model. Standardized
extensions are not expected to use this class.
The class definition is as follows:
NAME VendorPolicyCondition
DESCRIPTION A class that defines a registered means to describe
a policy condition.
DERIVED FROM PolicyCondition
ABSTRACT FALSE
PROPERTIES Constraint[ ]
ConstraintEncoding
6.6.1. The Multi-valued Property "Constraint"
This property provides a general extension mechanism for representing
policy conditions 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.
NOTE: CIM has a particular way of representing an array of octet
strings. (A single octet string can be represented as an ordered
array of uint8's, but this does not work
+------------------+
| System |
+------------------+
|CreationClassName |
|Name |
+------------------+
^ P
I PPPPPPPPPPPPPPPPPPPPPPPPPPPP
I P
+------------------+ +---------------v--------------+
| AdminDomain | | PolicyRule |
+------------------+ +------------------------------+
|CreationClassName | | System.CreationClassName |
|Name | | System.Name |
+------------------+ | CreationClassName |
^ | PolicyRuleName |
I +------------------------------+
I M
I M
+------------------+ M
| PolicyRepository | M
+------------------+ M
|CreationClassName | M
|Name | M
+------------------+ M
M M
M M
M M
+----v-------------------v----+
| PolicyCondition |
+-----------------------------+
| SystemCreationClassName |
| SystemName |
| PolicyRuleCreationClassName |
| PolicyRuleName |
| CreationClassName |
| PolicyConditionName |
+-----------------------------+
Figure 9. Manual Key Propagation for multi-valued properties
where each value is an octet string.) There is a qualifier
"Octetstring" Naming PolicyConditions
Looking at Figure 9, we see that can be applied to a multi-valued string property.
This qualifier functions exactly like an SMIv2 (SNMP) Textual
Convention, refining the syntax two key properties, CreationClassName
and semantics of Name, are defined in the existing CIM data
types "string". Strings with this qualifier consist of a 4-octet
length field, followed System class, and inherited by an even number of the characters A-F its
subclasses AdminDomain and 0-
9. The length is encoded as an 8-digit hexadecimal value, which
includes the 4 octets of the length field itself. For example, the
octet string 0x4a PolicyRepository. Since PolicyRule is encoded as 0x000000063441.
A policy decision point can readily determine whether it supports the
values stored in an instance of Constraint by checking the OID value
from ConstraintEncoding against the set of OIDs it recognizes. The
action for the policy decision point weak to take in case
System, these two keys are propagated to it; it does not
recognize the format of this data could itself be modeled as a policy
rule, governing the behavior of the policy decision point.
The property is defined as follows:
NAME Constraint
DESCRIPTION Extension mechanism for representing constraints
that have also has its own keys
CreationClassName and PolicyRuleName.
A similar approach, though not been modeled as specific properties.
The format of the values automatic, is identified by the OID
stored used in "manual key
propagation." Here is the property ConstraintEncoding.
SYNTAX string
QUALIFIER Octetstring approach for rule-specific and reusable
PolicyConditions:
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 37] 62]
Internet Draft Policy Core Information Model July October 2000
6.6.2.
o The Property "ConstraintEncoding"
This property identifies the encoding and semantics manual propagation of keys from PolicyRule to PolicyCondition
involves copying the Constraint
property values of PolicyRule's four key properties into
four similarly named key properties in this instance. The value PolicyCondition. From the
point of this view of the CIM specification language, the property
SystemName in PolicyCondition is a
single string, representing a single OID.
The completely new key property.
However, the relationship to the Name property in System is defined in
the description of SystemName.
o The manual propagation of keys from PolicyRepository to
PolicyCondition works in exactly the same way for the first two key
properties. However, since PolicyRepository doesn't include
PolicyRule properties, the PolicyRuleCreationClassName and
PolicyRuleName have no values. A special value, "No Rule", is
assigned to both of these properties in this case, indicating that
this instance of PolicyCondition is not named within the scope of any
particular policy rule.
The following section defines the specific CIM keys for PolicyCondition.
14.2.1. PolicyCondition's CIM Keys
PolicyCondition's key properties are defined in Reference [1] as follows:
NAME ConstraintEncoding SystemCreationClassName
DESCRIPTION An OID encoded as a string, identifying SystemCreationClassName represents the format
and semantics class name of
the CIM System object providing the naming scope for
the instance of PolicyCondition. For a rule-specific
policy condition, this instance's Constraint
property. The value is a dotted sequence the type of
decimal digits (for example, "1.2.100.200")
representing system (e.g.,
the arcs name of the OID. The characters class that created this instance) in
whose context the string are policy rule is defined. For a
reusable policy condition, this is set to
"CIM_PolicyRepository", if the UCS-2 characters
corresponding PolicyRepository object
is directly instantiated. Or, it is equal to the US ASCII encodings
class name of the
numeric characters and the period. PolicyRepository subclass that is
instantiated.
SYNTAX string
6.7. The Class "PolicyAction" [MaxLen 256]
QUALIFIER key
NAME SystemName
DESCRIPTION The purpose name of a the System object in whose scope this
policy action condition is to execute one or more operations
that will affect network traffic and/or systems, devices, etc. in
order to achieve a desired state. defined. This (new) state provides one or
more (new) behaviors. A policy action ordinarily changes property completes
the
configuration identification of one or more elements.
A PolicyRule contains one or more policy actions. A policy
administrator can assign an order to the actions associated with System object. For a
PolicyRule, complete with an indication of whether the indicated order rule-
specific policy condition, this is mandatory, recommended, or the name of no significance. Ordering the
instance of the
actions associated with a PolicyRule is accomplished via a property system in whose context the PolicyActionInPolicyRule aggregation.
The actions associated with a PolicyRule are executed if and only if
the overall condition(s) of the PolicyRule evaluates to TRUE.
The class definition of PolicyAction policy
rule is as follows:
NAME PolicyAction
DESCRIPTION A class representing defined. For a rule-specific or reusable policy action to be performed if the condition for
a policy rule evaluates to TRUE.
DERIVED FROM Policy
ABSTRACT FALSE
PROPERTIES NONE
No properties are defined for condition,
this class since it inherits all its
properties from Policy. The class exists as an abstract superclass
for domain-specific is name of the instance of PolicyRepository that
holds the policy actions, defined in subclasses. In an condition.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleCreationClassName
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 38] 63]
Internet Draft Policy Core Information Model July October 2000
implementation, various key/identification properties MUST be defined
for the class or its instantiable subclasses. The keys for
DESCRIPTION For a native
CIM implementation are defined in Appendix A, Section 14.3. Keys for
an LDAP implementation are defined in the LDAP mapping of this
information model [11].
When identifying and using the PolicyAction class, it is necessary to
remember that an action can be rule-specific or reusable. This was
discussed above in Section 5.1. The distinction between policy condition, this property
identifies the two types class name of policy actions lies in the associations policy rule instance,
in which an whose scope this instance can
participate, and in how the different instances are named.
Conceptually, of PolicyCondition
exists. For a reusable policy action resides in a policy repository,
and condition, this
property is named within the scope of set to a special value, "No Rule",
indicating that repository. On the other hand, this instance of PolicyCondition is
not unique to one policy rule.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleName
DESCRIPTION For a rule-specific policy action is named within condition, PolicyRuleName
completes the scope identification of the single
policy rule to PolicyRule object
with which it this condition is related.
The distinction between rule-specific and associated. For a
reusable PolicyActions
affects the CIM naming, defined in Appendix A, and the LDAP mapping
[11].
6.8. policy condition, a special value, "No Rule",
is used to indicate that this condition is reusable.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION The Class "VendorPolicyAction" class name of the PolicyCondition subclass that is
instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyConditionName
DESCRIPTION The purpose identifying name of this class is to provide a general extension mechanism
for representing policy actions that have not been modeled with
specific properties. Instead, the two properties ActionData condition.
SYNTAX string [MaxLen 256]
QUALIFIER key
14.3. Naming Instances of PolicyAction and
ActionEncoding are used to define Its Subclasses
From the content and format point of view of naming, the
action, as explained below.
As PolicyAction class and its name suggests, this
subclasses work exactly like the PolicyCondition class is intended and its
subclasses. See Section 14.2 and 14.2.1 for vendor-specific
extensions to details.
Specifically, the Policy Core Information Model. Standardized
extensions CIM keys of PolicyAction are:
o SystemCreationClassName
o SystemName
o PolicyRuleCreationClassName
o PolicyRuleName
o CreationClassName
o PolicyActionName
They are not expected to use this class.
The class definition is defined in Reference [1] as follows:
NAME VendorPolicyAction SystemCreationClassName
DESCRIPTION A SystemCreationClassName represents the class that defines a registered means to describe
a policy action.
DERIVED FROM PolicyAction
ABSTRACT FALSE
PROPERTIES ActionData[ ]
ActionEncoding
6.8.1. The Multi-valued Property "ActionData"
This property provides a general extension mechanism for representing
policy actions that have not been modeled with specific properties.
The format name of
the octet strings in the array is left unspecified in
this definition. It is determined by CIM System object providing the OID value stored in naming scope for
the
property ActionEncoding. Since ActionEncoding instance of PolicyAction. For a rule-specific
policy action, this is single-valued, all the values type of ActionData share system (e.g., the same format and semantics. See
Section 6.6.1 for a discussion of how CIM encodes an array of octet
strings.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 39] 64]
Internet Draft Policy Core Information Model July October 2000
A policy decision point can readily determine whether it supports the
values stored in an instance
name of ActionData by checking the OID value
from ActionEncoding against class that created this instance) in whose
context the policy rule is defined. For a reusable
policy action, this is set of OIDs to "CIM_PolicyRepository",
if the PolicyRepository object is directly
instantiated. Or, it recognizes. is equal to the class name of
the PolicyRepository subclass that is instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME SystemName
DESCRIPTION The action
for name of the policy decision point to take System object in case it does not recognize whose scope this
policy action is defined. This property completes the format
identification of this data could itself be modeled as the System object. For a rule-
specific policy rule,
governing action, this is the behavior name of the
instance of the system in whose context the policy decision point.
The property
rule is defined as follows: defined. For a reusable policy action, this
is name of the instance of PolicyRepository that holds
the policy action.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME ActionData PolicyRuleCreationClassName
DESCRIPTION Extension mechanism for representing actions that
have not been modeled as specific properties. The
format of For a rule-specific policy action, this property
identifies the values is identified by class name of the OID
stored policy rule instance,
in the whose scope this instance of PolicyAction exists.
For a reusable policy action, this property ActionEncoding. is set to
a special value, "No Rule", indicating that this
instance of PolicyAction is not unique to one policy
rule.
SYNTAX string [MaxLen 256]
QUALIFIER Octetstring
6.8.2. The Property "ActionEncoding"
This property identifies key
NAME PolicyRuleName
DESCRIPTION For a rule-specific policy action, PolicyRuleName
completes the encoding and semantics identification of the ActionData
property values in this instance. The value of PolicyRule object
with which this property action is associated. For a
single string, representing reusable
policy action, a single OID.
The property special value, "No Rule", is defined as follows:
NAME ActionEncoding
DESCRIPTION An OID encoded as a string, identifying the format
and semantics for used to
indicate that this instance's ActionData
property. The value action is a dotted sequence of
decimal digits (for example, "1.2.100.200")
representing the arcs of the OID. The characters
in the string are the UCS-2 characters
corresponding to the US ASCII encodings of the
numeric characters and the period. reusable.
SYNTAX string
6.9. The Class "PolicyRepository" [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION The class definition name of PolicyRepository the PolicyAction subclass that is as follows:
instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyRepository PolicyActionName
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
number The identifying name of unique associations.
DERIVED FROM AdminDomain
ABSTRACT FALSE this policy action.
SYNTAX string [MaxLen 256]
QUALIFIER key
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 40] 65]
Internet Draft Policy Core Information Model July October 2000
7. Association and Aggregation Definitions
The first
14.4. Naming Instances of PolicyRepository
An instance of PolicyRepository is named by the two subsections key properties
CreationClassName and Name that it inherits from its superclass
AdminDomain. These properties are actually defined in AdminDomain's
superclass, System, and then inherited by AdminDomain.
For instances of PolicyRepository itself, the value of CreationClassName
must be "CIM_PolicyRepository". (Recall that for readability the prefix
"CIM_" has been omitted from all class names in this section introduce associations document). If a
subclass of PolicyRepository (perhaps QosPolicyRepository) is defined and
aggregations as they are
instantiated, then the class name "CIM_QosPolicyRepository" is used in CIM.
CreationClassName.
The remaining subsections
present Name property simply completes the class definitions for identification of the associations and aggregations
that are part instance of
PolicyRepository.
14.5. Role of the Policy Core Information Model.
7.1. Associations
An association is a CreationClassName Property in Naming
To provide for more flexibility in instance naming, CIM construct representing makes use of a relationship between
two (or theoretically more) objects. It
property called CreationClassName. The idea of CreationClassName is modeled as to
provide another dimension that can be used to avoid naming collisions, in
the specific case of instances belonging to two different subclasses of a class
containing typically
common superclass. An example will illustrate how CreationClassName
works.
Suppose we have instances of two object references. Associations different subclasses of PolicyCondition,
FrameRelayPolicyCondition and BgpPolicyCondition, and that these
instances apply to the same context. If we had only the single key
property PolicyConditionName available for distinguishing the two
instances, then a collision would result from naming both of the
instances with the key value PCName = "PC-1". Thus policy administrators
from widely different disciplines would have to coordinate their naming
of PolicyConditions for this context.
With CreationClassName, collisions of this type can be
defined between classes eliminated,
without affecting any of requiring coordination among the related classes.
That is, addition of an association does not affect policy administrators. The two
instances can be distinguished by giving their CreationClassNames
different values. One instance is now identified with the interface of two keys
CreationClassName = "FrameRelayPolicyCondition" + PCName = "PC-1",
while the related classes.
7.2. Aggregations
An aggregation other is a strong form identified with
CreationClassName = "BgpPolicyCondition" + PCName = "PC-1".
Each of an association, which usually
represents a "whole-part" or a "collection" relationship. For
example, CIM uses an aggregation to represent the containment
relationship between a system and instantiable classes in the components that make up Core Model includes the
system. Aggregation
CreationClassName property as a "whole-part" relationship often implies, but
does not require, that the aggregated objects have mutual
dependencies.
7.3. The Abstract Aggregation "PolicyComponent
This abstract aggregation defines key in addition to its own class-specific
key property.
Moore, et al. Expires: Oct 2000 + 6 months [Page 66]
Internet Draft Policy Core Information Model October 2000
14.6. Object References
Today, all CIM associations involve two object references references. CIM
decomposes an object reference into two parts: a high-order part that will be
overridden in each of five subclasses, to become references to the
concrete policy classes PolicyGroup, PolicyRule, PolicyCondition,
PolicyAction,
identifies an object manager and PolicyTimePeriodCondition. The value of the
abstract superclass is to convey that all five subclasses have the
same "whole-part" semantics, namespace, and for ease of query to locate all
"components" of a PolicyGroup or PolicyRule. model path that
identifies an object instance within a namespace. The model path, in
turn, can be decomposed into an object class definition for the aggregation is as follows:
NAME PolicyComponent
DESCRIPTION A generic aggregation used identifier and a set of key
values needed to establish 'part of'
relationships between the subclasses identify an instance of Policy. For
example, the PolicyConditionInPolicyRule
aggregation defines that PolicyConditions are class.
Because the object class identifier is part of the model path, a PolicyRule.
ABSTRACT TRUE
PROPERTIES GroupComponent[ref Policy[0..n]]
PartComponent[ref Policy[0..n]]
7.4. The Aggregation "PolicyGroupInPolicyGroup" CIM
object reference is strongly typed. The GroupComponent object reference
in the PolicyGroupInPolicyGroup aggregation enables policy groups to be
nested. This is critical for scalability and manageability, as it
enables complex policies to be constructed from multiple simpler
Moore, et al. Expires: Jul 2000 + 6 months [Page 41]
Internet Draft Policy Core Information Model July 2000
policies association, for administrative convenience. For example, can only point
to an instance of PolicyGroup, or to an instance of a policy group
representing policies for the US might have nested within it policy
groups for the Eastern and Western US.
A PolicyGroup may aggregate other PolicyGroups via subclass of
PolicyGroup. Contrast this aggregation,
or with LDAP, where a DN pointer is completely
untyped: it may aggregate PolicyRules via the PolicyRuleInPolicyGroup
aggregation. But identifies (by DN) an entry, but places no restriction on
that entry's object class(es).
An important difference between CIM property definitions and LDAP
attribute type definitions was identified earlier in Section 6: while an
LDAP attribute type definition has global scope, a single PolicyGroup SHALL NOT do both.
The class CIM property
definition for applies only to the aggregation is as follows:
NAME PolicyGroupInPolicyGroup
DESCRIPTION A class representing the aggregation of
PolicyGroups by a higher-level PolicyGroup.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyGroup[0..n]]
PartComponent[ref PolicyGroup[0..n]]
7.4.1. The Reference "GroupComponent"
This property in which it is inherited from PolicyComponent, and overridden defined. Thus
properties having the same name in two different classes are free to
become have
different data types. CIM takes advantage of this flexibility by
allowing the data type of an object reference to be overridden in a PolicyGroup that contains one or more
other PolicyGroups. Note that for any single instance
subclass of the
aggregation association class PolicyGroupInPolicyGroup, this property (like all
Reference properties) is single-valued. The [0..n] cardinality
indicates that there may be 0, 1, or more than one PolicyGroups that
contain any given PolicyGroup.
7.4.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to
become an in which it was initially defined.
For example, the object reference GroupComponent is defined in the
abstract aggregation class PolicyComponent to be a PolicyGroup contained by one or more
other PolicyGroups. Note that for any single reference to an
instance of the
aggregation class PolicyGroupInPolicyGroup, this property (like all
Reference properties) Policy. This data type for GroupComponent is single-valued. The [0..n] cardinality
indicates that a given PolicyGroup may contain 0, 1, or more than one
other PolicyGroups.
7.5. The Aggregation "PolicyRuleInPolicyGroup"
A policy group may aggregate one or more policy rules, via the
PolicyRuleInPolicyGroup aggregation. Grouping then
overridden in subclasses of policy rules into a
policy group is again PolicyComponent. In
PolicyGroupInPolicyGroup, for administrative convenience; example, GroupComponent becomes a policy rule
may also be used by itself, without belonging reference
to an instance of PolicyGroup. But in PolicyConditionInPolicyRule it
becomes a policy group.
A PolicyGroup may aggregate PolicyRules via reference to an instance of PolicyRule. Of course there is not
total freedom in this aggregation, or it
may aggregate other PolicyGroups via the PolicyGroupInPolicyGroup
aggregation. But overriding of object references. In order to
remain consistent with its abstract superclass, a single PolicyGroup SHALL NOT do both.
The subclass of
PolicyComponent can only override GroupComponent to be a reference to a
subclass of Policy. A Policy class definition is the generic context for the aggregation is as follows:
NAME PolicyRuleInPolicyGroup
GroupComponent reference in PolicyComponent.
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 42] 67]
Internet Draft Policy Core Information Model July October 2000
DESCRIPTION A class representing the aggregation of PolicyRules
by a PolicyGroup.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyGroup[0..n]]
PartComponent[ref PolicyRule[0..n]]
7.5.1.
15. Appendix B: The Core Policy MOF
// ==================================================================
// Title: Core Policy MOF Specification 2.4
// Filename: CIM_Policy24.MOF
// Version: 2.4
// Release: 0
// Description: The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to
become an object reference to a PolicyGroup that contains one or more
PolicyRules. Note classes below are listed in an order that for any single instance of
// avoids forward references. Required objects, defined
// by other working groups, are omitted.
// Date: 06/27/2000
// CIMCR516a - Rooted the aggregation
class PolicyRuleInPolicyGroup, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, model associations under Policy
// Component or more than one PolicyGroups that contain any
given PolicyRule.
7.5.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden PolicyInSystem. Corrected PolicyCondition/
// PolicyActionInPolicyRepository to
become an object reference subclass from
// PolicyInSystem (similar to a PolicyRule contained by one or more
PolicyGroups. Note that for any single instance of the aggregation
class PolicyRuleInPolicyGroup, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyGroup may contain 0, 1, or more than one PolicyRules.
7.6. The Aggregation "PolicyConditionInPolicyRule"
A policy rule aggregates zero or more Groups and Roles 'InSystem')
// ==================================================================
// Author: DMTF SLA (Service Level Agreement) Working Group
// ==================================================================
// Pragmas
// ==================================================================
#pragma Locale ("en-US")
// ==================================================================
// Policy
// ==================================================================
[Abstract, Description (
"An abstract class describing common properties of all "
"policy rule-related subclasses, such as PolicyGroup, Policy"
"Rule and PolicyCondition. All instances of the PolicyCondition
class, via the PolicyConditionInPolicyRule association. A policy rule
that aggregates zero policy conditions is not a valid rule -- it may,
for example, rule-"
"related entities will be in the process created from subclasses of being entered into the policy
repository. A policy rule has no effect until it is valid. CIM_"
"Policy. The
conditions aggregated by exception to this statement is PolicyRepository "
"which is a policy rule are grouped into two levels of
lists: either an ORed set type of ANDed sets CIM_System.")
]
class CIM_Policy : CIM_ManagedElement
{
[Description (
"A user-friendly name of conditions (DNF, the
default) or an ANDed set this policy-related object.")
]
string CommonName;
[Description (
"An array of ORed sets keywords for characterizing / categorizing "
"policy objects. Keywords are of conditions (CNF). Individual
conditions in these lists may be negated. The property
ConditionListType (in PolicyRule) specifies which one of these two
grouping schemes applies to a particular PolicyRule. The conditions
are used to determine whether to perform the actions associated with
the PolicyRule.
One types: \n"
" o Keywords defined in this and other MOFs, or more policy time periods may be among the conditions associated
with in DMTF "
" white papers. These keywords provide a vendor-"
" independent, installation-independent way of "
" characterizing policy rule via the PolicyConditionInPolicyRule association.
In this case, the time periods are simply additional conditions to be
evaluated along with any other conditions specified for the rule.
The class definition objects. \n"
" o Installation-dependent keywords for the aggregation is as follows:
NAME PolicyConditionInPolicyRule
DESCRIPTION A class representing the aggregation of
PolicyConditions by a PolicyRule.
DERIVED FROM PolicyComponent characterizing "
" policy objects. Examples include 'Engineering', "
" 'Billing', and 'Review in December 2000'. \n"
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 43] 68]
Internet Draft Policy Core Information Model July October 2000
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyCondition[0..n]]
GroupNumber
ConditionNegated
7.6.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent,
"This MOF defines the following keywords: 'UNKNOWN', "
"'CONFIGURATION', 'USAGE', 'SECURITY', 'SERVICE', "
"'MOTIVATIONAL', 'INSTALLATION', and overridden to
become an object reference to a PolicyRule that contains one or more
PolicyConditions. Note that for any single instance of 'EVENT'. These "
"concepts are self-explanatory and are further discussed "
"in the
aggregation class PolicyConditionInPolicyRule, SLA/Policy White Paper. One additional keyword "
"is defined: 'POLICY'. The role of this property (like all
Reference properties) keyword is single-valued. The [0..n] cardinality
indicates to "
"identify policy-related instances that there may not be 0, 1, or more than one PolicyRules that
contain any given PolicyCondition.
7.6.2. otherwise "
"identifiable, in some implementations. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to
become an object reference to a PolicyCondition contained by one or
more PolicyRules. Note that for any single instance keyword 'POLICY' "
"is NOT mutually exclusive of the
aggregation class PolicyConditionInPolicyRule, this property (like all
Reference properties) other keywords "
"specified above.")
]
string PolicyKeywords [];
};
// ==================================================================
// PolicyComponent
// ==================================================================
[Association, Abstract, Aggregation, Description (
"CIM_PolicyComponent is single-valued. The [0..n] cardinality
indicates that a given PolicyRule may contain 0, 1, or more than one
PolicyConditions.
7.6.3. The Property "GroupNumber"
This property contains an integer identifying the group generic association used to which "
"establish 'part of' relationships between the
condition referenced by subclasses of "
"CIM_Policy. For example, the PartComponent property is assigned PolicyConditionInPolicyRule "
"association defines that PolicyConditions are part of a "
"PolicyRule.")
]
class CIM_PolicyComponent
{
[Aggregate, Key, Description (
"The parent Policy in
forming the overall conditional expression for the policy rule
identified by the GroupComponent reference.
The property is defined as follows:
NAME GroupNumber
DESCRIPTION Unsigned integer indicating the group to which the
condition identified by association.")
]
CIM_Policy REF GroupComponent;
[Key, Description (
"The child/part Policy in the PartComponent property 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 assigned.
SYNTAX uint16
7.6.4. The Property "ConditionNegated" ComputerSystems "
"where Policies are 'running' or they may be Policy"
"Repositories where Policies are stored. This property is a boolean, indicating whether relationship "
"is similar to the condition
referenced concept of CIM_Services being dependent "
"on CIM_Systems as defined by the PartComponent property is negated in forming the
overall conditional expression HostedService "
"association. \n"
" Cardinality is Max(1) for the policy rule identified by Antecedent/System "
"reference since Policies can only be hosted in at most one "
"System context. Some subclasses of the
GroupComponent reference.
The property is defined as follows:
NAME ConditionNegated association will "
"further refine this definition to make the Policies Weak "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 44] 69]
Internet Draft Policy Core Information Model July October 2000
DESCRIPTION Indication
"to Systems. Other subclasses of whether the condition identified by
the PartComponent property is negated. (TRUE
indicates that PolicyInSystem will "
"define an optional hosting relationship. Examples of each "
"of these are the condition is negated, FALSE
indicates that it is not negated.)
SYNTAX boolean
7.7. The Aggregation "PolicyRuleValidityPeriod"
A different relationship between a policy rule 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;
};
// ==================================================================
// PolicyGroup
// ==================================================================
[Description (
"A container for either a policy time
period (than PolicyConditionInPolicyRule) is represented by the
PolicyRuleValidityPeriod aggregation. The latter describes scheduled
activation set of related PolicyGroups "
"or a set of related PolicyRules, but not both. Policy"
"Groups are defined and deactivation named relative to the CIM_System "
"which provides their context.")
]
class CIM_PolicyGroup : CIM_Policy
{
[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 policy rule.
If a policy rule is associated with multiple policy time periods via
this association, then class or the rule is active if at least one "
"subclass used in the creation of an instance. When used "
"with the time
periods indicates that it is active. (In other words, the time
periods are ORed key properties of this class, this property "
"allows all instances of this class and its subclasses to determine whether the rule is active.) "
"be uniquely identified.") ]
string CreationClassName;
[Key, MaxLen (256), Description (
"A user-friendly name of this PolicyGroup.")
]
string PolicyGroupName;
};
// ==================================================================
Moore, et al. Expires: Oct 2000 + 6 months [Page 70]
Internet Draft Policy Core Information Model October 2000
// PolicyGroupInPolicyGroup
// ==================================================================
[Association, Aggregation, Description (
"A relationship that aggregates one or more lower-level "
"PolicyGroups into a higher-level Group. A policy
time period Policy"
"Group may be aggregate either PolicyRules or other Policy"
"Groups, but not both.")
]
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 multiple policy rules. A rule another Group.")
]
CIM_PolicyGroup REF PartComponent;
};
// ==================================================================
// PolicyGroupInSystem
// ==================================================================
[Association, Description (
"An association that
does not point links a PolicyGroup to the System "
"in whose scope the Group is defined.")
]
class CIM_PolicyGroupInSystem : CIM_PolicyInSystem
{
[Override ("Antecedent"), Min(1), Max(1), Description (
"The System in whose scope a policy time period via this aggregation is, from PolicyGroup is defined.")
]
CIM_System REF Antecedent;
[Override ("Dependent"), Weak, Description (
"A PolicyGroup named within the point of view scope of scheduling, always active. It may, however, be
inactive for other reasons.
Time periods are a general concept that can be used in other
applications. However, they are mentioned explicitly here in this
specification since they are frequently used in policy applications. System.")
]
CIM_PolicyGroup REF Dependent;
};
// ==================================================================
// PolicyRule
// ==================================================================
[Description (
" The central class definition for the aggregation is as follows:
NAME PolicyRuleValidityPeriod
DESCRIPTION A class representing the aggregation of
PolicyTimePeriodConditions by a PolicyRule.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyTimePeriodCondition[0..n]]
7.7.1. The Reference "GroupComponent"
This property is inherited from PolicyComponent, and overridden to
become an object reference to 'If Condition then "
"Action' semantics associated with a policy rule. "
"A PolicyRule that contains one or more
PolicyTimePeriodConditions. Note that for any single instance of condition, in the
aggregation class PolicyRuleValidityPeriod, this property (like all
Reference properties) most general sense, is single-valued. The [0..n] cardinality
indicates that there "
"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 0, 1, negated (NOT C) or more than one PolicyRules that
contain any given PolicyTimePeriodCondition.
7.7.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to
become an object reference to a PolicyTimePeriodCondition contained unnegated (C). "
"The actions specified by
one or more PolicyRules. Note that for any single instance of a PolicyRule are to be performed "
"if and only if the
aggregation class PolicyRuleValidityPeriod, this property (like all PolicyRule condition (whether it is "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 45] 71]
Internet Draft Policy Core Information Model July October 2000
Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyRule may contain 0, 1, or more than one
PolicyTimePeriodConditions.
7.8. The Aggregation "PolicyActionInPolicyRule"
A policy rule may aggregate zero or more policy actions. A policy
rule that aggregates zero policy actions is not a valid rule -- it
may, for example, be
"represented in the process of being entered into the policy
repository. A policy rule has no effect until it is valid. The DNF or CNF) evaluates to TRUE.\n\n"
" "
"The conditions and 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, "
"are modeled, respectively, with subclasses of Policy"
"Condition and PolicyAction. These condition and action "
"objects are tied to instances of PolicyRule by the Policy"
"ConditionInPolicyRule and PolicyActionInPolicyRule aggregation can "
"aggregations.\n\n"
" "
"A PolicyRule may also be used
to express an order.
This aggregation does not indicate whether a specified action order is
required, recommended, associated with one or of no significance; more policy "
"time periods, indicating the property
SequencedActions in schedule according to which the aggregating instance of PolicyRule "
"policy rule is active and inactive. In this case it is the "
"PolicyRuleValidityPeriod aggregation that provides this indication.
The "
"linkage.\n\n"
" "
"The PolicyRule class definition uses the property ConditionListType, to "
"indicate whether the conditions for the rule are in DNF or "
"CNF. The PolicyConditionInPolicyRule aggregation is as follows:
NAME PolicyActionInPolicyRule
DESCRIPTION A class representing contains "
"two additional properties to complete the aggregation representation of
PolicyActions by a PolicyCondition.
DERIVED FROM PolicyComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRule[0..n]]
PartComponent[ref PolicyAction[0..n]]
ActionOrder
7.8.1. "
"the Rule's conditional expression. The Reference "GroupComponent"
This property first of these "
"properties is inherited from PolicyComponent, and overridden to
become an object reference integer to a PolicyRule that contains partition the referenced "
"PolicyConditions into one or more
PolicyActions. Note 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 for any single instance aggregates five "
"PolicyConditions C1 through C5, with the following values "
"in the properties of the aggregation
class PolicyActionInPolicyRule, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that 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 may be 0, 1, or more than one PolicyRules that contain any given
PolicyAction.
7.8.2. The Reference "PartComponent"
This property is inherited from PolicyComponent, and overridden to
become an object reference to a PolicyAction contained by one or more
PolicyRules. Note that for any single instance unambiguous specification of "
"the overall condition that is tested to determine whether "
"to perform the aggregation PolicyActions associated with the PolicyRule.")
]
class PolicyActionInPolicyRule, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRule may contain 0, 1, or more than one PolicyActions. CIM_PolicyRule : CIM_Policy
{
[Propagated("CIM_System.CreationClassName"),
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 46] 72]
Internet Draft Policy Core Information Model July October 2000
7.8.3. The Property "ActionOrder"
This property provides an unsigned integer 'n' that indicates the
relative position of an action in the sequence of actions associated
with a policy rule. When 'n' is a positive integer, it
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 a
place in the sequence name of actions to be performed, with smaller
integers indicating earlier positions in the sequence. The special
value '0' indicates "don't care". If two class or more actions have the
same non-zero sequence number, they may be performed in any order, but
they must all be performed at the appropriate place "
"subclass used in the overall
action sequence.
A series creation of examples will make ordering an instance. When used "
"with the other key properties of actions clearer:
o If this class, this property "
"allows all actions have the same sequence number, regardless 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
it this PolicyRule is '0' administratively "
"enabled, administratively disabled, or non-zero, any order enabled for "
"debug. When the property has the value 3 (\"enabledFor"
"Debug\"), the entity evaluating the PolicyConditions is acceptable.
o The values
1:ACTION A
2:ACTION B
1:ACTION C
3:ACTION D
indicate two acceptable orders: A,C,B,D or C,A,B,D, since A and C
can be performed in either order, "
"instructed to evaluate the conditions for the Rule, but only at not "
"to perform the '1' position.
o The values
0:ACTION A
2:ACTION B
3:ACTION C
3:ACTION D
require that B,C, and D occur either as B,C,D or actions if the PolicyConditions evaluate to "
"TRUE. This serves as B,D,C. Action
A may appear at a debug vehicle when attempting to "
"determine what policies would execute in a particular "
"scenario, without taking any point relative actions to B,C, and D. Thus the
complete set of acceptable orders is: A,B,C,D; B,A,C,D; B,C,A,D;
B,C,D,A; A,B,D,C; B,A,D,C; B,D,A,C; B,D,C,A.
Note that change state "
"during the non-zero sequence numbers need not start with '1', and
they need not be consecutive. All that matters is their relative
magnitude. debugging. The property default value is defined as follows:
NAME ActionOrder
DESCRIPTION Unsigned integer indicating 1
(\"enabled\")."),
ValueMap { "1", "2", "3" },
Values { "enabled", "disabled", "enabledForDebug" }
]
uint16 Enabled;
[Description (
"Indicates whether the relative position list of an action PolicyConditions "
"associated with this PolicyRule is in the sequence of actions aggregated
by a policy rule.
SYNTAX 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;
[Description (
"A non-negative integer for prioritizing this Policy"
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 47] 73]
Internet Draft Policy Core Information Model July October 2000
7.9. The Abstract Association "PolicyInSystem"
This abstract association inherits two object references from a
higher-level CIM association class, Dependency. It overrides these
object references to make them references
"Rule relative to instances 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 classes
System Policy"
"Conditions and Policy. Subclasses execution of PolicyInSystem then override these
object references again, to make them references PolicyActions (if the "
"Conditions evaluate to concrete policy
classes. TRUE) is required. The value "
"evaluation of a PolicyRule MUST be attempted if the abstract superclass "
"Mandatory property value is to convey that all subclasses
have TRUE. If the same "dependency" semantics, and for ease Mandatory "
"property is FALSE, then the evaluation of query to locate
all the Rule "
"is 'best effort' and MAY be ignored.")
]
boolean Mandatory;
[Description (
"This property gives a policy "dependencies" on administrator a System. These dependencies are related
to scoping or hosting of way "
"of specifying how the Policy.
The class definition for ordering of the association PolicyActions "
"associated with this PolicyRule is as follows:
NAME PolicyInSystem
DESCRIPTION A generic association used to establish dependency
relationships between Policies and the Systems that
host them.
DERIVED FROM Dependency
ABSTRACT TRUE
PROPERTIES Antecedent[ref System[0..1]]
Dependent[ref Policy[0..n]]
7.10. The Weak Association "PolicyGroupInSystem"
This association links a PolicyGroup to be interpreted. "
"Three values are supported:\n"
" o mandatory(1): Do the System actions in whose scope the
PolicyGroup is defined.
The class definition for indicated "
" order, or don't do them at all.\n"
" o recommended(2): Do the association is as follows:
NAME PolicyGroupInSystem
DESCRIPTION A class representing 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 fact that a PolicyGroup "
" order.\n"
"The default value is
defined within the scope of a System.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref System[1..1]]
Dependent[ref PolicyGroup[weak]]
7.10.1. The Reference "Antecedent"
This 3 (\"dontCare\")."),
ValueMap { "1", "2", "3" },
Values { "mandatory", "recommended", "dontCare" }
]
uint16 SequencedActions;
[Description (
"This property is inherited from PolicyInSystem, represents the roles and overridden to
restrict its cardinality to [1..1]. It serves as an object reference
to a System that provides role combinations "
"associated with a scope for PolicyRule. Each value represents one "
"role or more PolicyGroups. role combination. Since this is a weak association, multi-valued "
"property, more than one role or combination can be associated "
"with a single policy rule. Each value is a string of the cardinality "
"form:\n"
" <RoleName>[&&<RoleName>]*\n"
"where the individual role names appear in alphabetical order "
"(according to the collating sequence for this object reference
is always 1, UCS-2).")
]
string PolicyRoles [];
};
// ==================================================================
// PolicyRuleInPolicyGroup
// ==================================================================
[Association, Aggregation, Description (
"A relationship that is, aggregates one or more PolicyRules "
"into a PolicyGroup. A PolicyGroup is always defined within the scope
of exactly one System. may aggregate either "
"PolicyRules or other PolicyGroups, but not both.")
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 48] 74]
Internet Draft Policy Core Information Model July October 2000
7.10.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to
become an object reference to a PolicyGroup defined within the scope
of a System. Note that for any single instance of the association
]
class PolicyGroupInSystem, this property (like all Reference
properties) is single-valued. The [0..n] cardinality indicates CIM_PolicyRuleInPolicyGroup : CIM_PolicyComponent
{
[Override ("GroupComponent"), Aggregate, Description (
"A PolicyGroup that a
given System may have 0, 1, aggregates one or more than one PolicyGroups defined
within its scope.
7.11. The Weak Association "PolicyRuleInSystem"
Regardless of whether it belongs to a PolicyGroup (or to multiple
PolicyGroups), a PolicyRule is itself defined within the scope of PolicyRules.")
]
CIM_PolicyGroup REF GroupComponent;
[Override ("PartComponent"), Description (
"A PolicyRule aggregated by a
System. This PolicyGroup.")
]
CIM_PolicyRule REF PartComponent;
};
// ==================================================================
// PolicyRuleInSystem
// ==================================================================
[Association, Description (
"An association that links a PolicyRule to the System in "
"in whose scope the PolicyRule is defined.
The class definition for the association Rule is as follows:
NAME PolicyRuleInSystem
DESCRIPTION A defined.")
]
class representing the fact that a PolicyRule is
defined within the scope of a System.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref System[1..1]]
Dependent[ref PolicyRule[weak]]
7.11.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to
restrict its cardinality to [1..1]. It serves as an object reference
to a CIM_PolicyRuleInSystem : CIM_PolicyInSystem
{
[Override ("Antecedent"), Min(1), Max(1), Description (
"The System that provides a in whose scope for one or more PolicyRules. Since
this is a weak association, the cardinality for this object reference
is always 1, that is, a PolicyRule is always defined within the scope
of exactly one System.
7.11.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to
become an object reference to a defined.")
]
CIM_System REF Antecedent;
[Override ("Dependent"), Weak, Description (
"A PolicyRule defined named within the scope of a System. Note that for any single instance of the association System.")
]
CIM_PolicyRule REF Dependent;
};
// ==================================================================
// PolicyRepository
// ==================================================================
[Description (
"A class
PolicyRuleInSystem, this property (like all Reference properties) is
single-valued. The [0..n] cardinality indicates that a given System
may have 0, 1, or more than one PolicyRules representing an administratively defined within its scope.
7.12. The Association "PolicyConditionInPolicyRepository"
A "
"container for reusable policy condition is always related to a single
PolicyRepository, via the PolicyConditionInPolicyRepository
association. This is policy-related information. "
"This class does not true for all PolicyConditions, however. An 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 PolicyCondition that represents a rule-specific condition
is not related to any policy repository via this association. class uses the NameFormat value"
"\"PolicyRepository\", which is defined in the AdminDomain"
"class.")
]
class CIM_PolicyRepository : CIM_AdminDomain
{
};
// ==================================================================
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 49] 75]
Internet Draft Policy Core Information Model July October 2000
The class definition for the association is as follows:
NAME PolicyConditionInPolicyRepository
DESCRIPTION A class representing the inclusion of a reusable
PolicyCondition in a PolicyRepository.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref PolicyRepository[0..1]]
Dependent[ref PolicyCondition[0..n]]
7.12.1. The Reference "Antecedent"
This property is inherited from PolicyInSystem, and overridden to
become an object reference to a PolicyRepository containing
// PolicyRepositoryInPolicyRepository
// ==================================================================
[Association, Aggregation, Description (
"A relationship that aggregates one or more PolicyConditions. A reusable PolicyCondition is always related
to exactly one lower-level "
"PolicyRepositories into a higher-level Repository.")
]
class CIM_PolicyRepositoryInPolicyRepository : CIM_SystemComponent
{
[Override ("GroupComponent"), Aggregate, Description (
"A PolicyRepository via the
PolicyConditionInPolicyRepository association. The [0..1] cardinality
for this property covers the two types of PolicyConditions: 0 for that aggregates other Repositories.")
]
CIM_PolicyRepository REF GroupComponent;
[Override ("PartComponent"), Description (
"A PolicyRepository aggregated by another Repository.")
]
CIM_PolicyRepository REF PartComponent;
};
// ==================================================================
// PolicyCondition
// ==================================================================
[Abstract, Description (
"A class representing a rule-specific PolicyCondition, 1 for a or reusable one.
7.12.2. The Reference "Dependent"
This property is inherited from PolicyInSystem, and overridden to
become an object reference policy "
"condition to be evaluated in conjunction with a Policy"
"Rule. Since all operational details of a PolicyCondition included "
"are provided in a
PolicyRepository. Note that for any single instance subclasses of the
association class PolicyConditionInPolicyRepository, this property
(like all Reference properties) object, this class is single-valued. "
"abstract.")
]
class CIM_PolicyCondition : CIM_Policy
{
[Key, MaxLen (256), Description (
" The [0..n]
cardinality indicates that a given PolicyRepository may contain 0, 1, name of the class or more than one PolicyConditions.
7.13. The Association "PolicyActionInPolicyRepository"
A reusable policy action the subclass used in the "
"creation of the System object in whose scope this "
"PolicyCondition is always related defined.\n\n"
" "
"This property helps to a single
PolicyRepository, via identify the PolicyActionInPolicyRepository association.
This is not true for all PolicyActions, however. An System object in "
"whose scope this instance of
PolicyAction that represents PolicyCondition exists. "
"For a rule-specific action is not related to
any policy repository via PolicyCondition, this association.
The class definition for is the association System "
"in whose context the PolicyRule is defined. For a "
"reusable PolicyCondition, this is as follows:
NAME PolicyActionInPolicyRepository
DESCRIPTION A class representing the inclusion instance of "
"PolicyRepository (which is a reusable
PolicyAction in a PolicyRepository.
DERIVED FROM PolicyInSystem
ABSTRACT FALSE
PROPERTIES Antecedent[ref PolicyRepository[0..1]]
Dependent[ref PolicyAction[0..n]]
7.13.1. The Reference "Antecedent"
This subclass of System) that "
"holds the Condition.\n\n"
" "
"Note that this property, and the analogous property is inherited "
"SystemName, do not represent propagated keys from PolicyInSystem, and overridden to
become an object reference "
"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 a PolicyRepository containing one or
more PolicyActions. A reusable PolicyAction which "
"this PolicyCondition is always related to related, either directly via the "
"PolicyConditionInPolicyRepository aggregation or indirectly "
"via the PolicyConditionInPolicyRule aggregation.")
]
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 50] 76]
Internet Draft Policy Core Information Model July October 2000
exactly one PolicyRepository via the PolicyActionInPolicyRepository
association.
string SystemCreationClassName;
[Key, MaxLen (256), Description (
" The [0..1] cardinality for name of the System object in whose scope this "
"PolicyCondition is defined.\n\n"
" "
"This property covers completes the two
types identification of PolicyActions: 0 for the System "
"object in whose scope this instance of PolicyCondition "
"exists. For a rule-specific PolicyAction, 1 for 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 one.
7.13.2. The Reference "Dependent"
This property PolicyCondition, a "
"special value, 'NO RULE', should be used to indicate "
"that this Condition is inherited from PolicyInSystem, reusable and overridden to
become an object reference to a PolicyAction included in not associated "
"with a
PolicyRepository. Note that for any single instance PolicyRule.")
]
string PolicyRuleName;
[Key, MaxLen (256), Description (
"CreationClassName indicates the name of the
association class PolicyActionInPolicyRepository, this property (like
all Reference properties) is single-valued. The [0..n] cardinality
indicates that a given PolicyRepository may contain 0, 1, or more than
one PolicyActions.
7.14. The Aggregation "PolicyRepositoryInPolicyRepository"
The PolicyRepositoryInPolicyRepository aggregation enables policy
repositories to be nested. This derives from the higher level CIM
association, CIM_SystemComponent, describing that Systems contain
other ManagedSystemElements. This superclass could not be "
"subclass used for
the other Policy aggregations, since Policies are not
ManagedSystemElements, but ManagedElements.
The class definition for the aggregation is as follows:
NAME PolicyRepositoryInPolicyRepository
DESCRIPTION A class representing in the aggregation creation of
PolicyRepositories by a higher-level
PolicyRepository.
DERIVED FROM SystemComponent
ABSTRACT FALSE
PROPERTIES GroupComponent[ref PolicyRepository[0..n]]
PartComponent[ref PolicyRepository[0..n]]
7.14.1. The Reference "GroupComponent"
This property is inherited from the CIM class SystemComponent, and
overridden to become an object reference to a PolicyRepository that
contains one or more instance. When used "
"with the other PolicyRepositories. Note that for any
single instance key properties of the aggregation class
PolicyRepositoryInPolicyRepository, this class, this property (like "
"allows all Reference
properties) is single-valued. The [0..n] cardinality indicates that
there may be 0, 1, or more than one PolicyRepositories that contain
any given PolicyRepository.
7.14.2. The Reference "PartComponent"
This property is inherited from the CIM instances of this class SystemComponent, and
overridden to become an object reference its subclasses to a PolicyRepository
contained by one "
"be uniquely identified.") ]
string CreationClassName;
[Key, MaxLen (256), Description (
"A user-friendly name of this PolicyCondition.")
]
string PolicyConditionName;
};
// ==================================================================
// PolicyConditionInPolicyRule
// ==================================================================
[Association, Aggregation, Description (
" A PolicyRule aggregates zero or more other PolicyRepositories. Note that for any
single instance instances of the aggregation class
PolicyRepositoryInPolicyRepository, this property (like all Reference "
"PolicyCondition class, via the PolicyConditionInPolicyRule "
"association. A Rule that aggregates zero Conditions is not "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 51] 77]
Internet Draft Policy Core Information Model July October 2000
properties) is single-valued. The [0..n] cardinality indicates that a
given PolicyRepository may contain 0, 1, or more than one other
PolicyRepositories.
8. Intellectual Property
The IETF takes no position regarding the validity or scope of any
intellectual property or other rights that might be claimed to pertain
to the implementation or use of the technology described in this
document or the extent to which any license under such rights might or
might not be available; neither does it represent that
"valid -- it has made any
effort to identify any such rights. Information on the IETF's
procedures with respect to rights in standards-track and standards-
related documentation can may, however, be found in BCP-11.
Copies of claims of rights made available for publication and any
assurances of licenses to be made available, or the result process of an
attempt made to obtain being entered "
"into a general license PolicyRepository or permission being defined for the use of
such proprietary rights a System. Note "
"that a PolicyRule should have no effect until it is valid.\n\n"
" "
"The Conditions aggregated by implementers a PolicyRule are grouped into "
"two levels of lists: either an ORed set of ANDed sets of "
"conditions (DNF, the default) or users an ANDed set of this specification
can ORed sets "
"of conditions (CNF). Individual PolicyConditions in these "
"lists may be obtained from the IETF Secretariat. negated. The IETF invites any interested party property ConditionListType "
"specifies which of these two grouping schemes applies to bring a "
"particular PolicyRule.\n\n"
" "
"In either case, PolicyConditions are used to its attention any
copyrights, patents or patent applications, determine whether "
"to perform the PolicyActions associated with the
PolicyRule.\n\n"
" "
"One or other proprietary
rights which may cover technology that more PolicyTimePeriodConditions may be required to practice
this standard. Please address among the information to "
"conditions associated with a PolicyRule via the IETF Executive
Director.
9. Acknowledgements
The Policy Core Information Model in Policy"
"ConditionInPolicyRule association. In this document is closely based on
the work of case, the DMTF's Service Level Agreements working group, so
thanks time "
"periods are due simply additional Conditions to be evaluated "
"along with any others that are specified for the members of Rule. ")
]
class CIM_PolicyConditionInPolicyRule : CIM_PolicyComponent
{
[Override ("GroupComponent"), Aggregate, Description (
"This property represents the PolicyRule that working group. Several of "
"contains one or more PolicyConditions.")
]
CIM_PolicyRule REF GroupComponent;
[Override ("PartComponent"), Description (
"This property holds the
policy classes in this model first appeared in early drafts on IPSec
policy and QoS policy. The authors name of these drafts were Partha
Bhattacharya, Rob Adams, William Dixon, Roy Pereira, Raju Rajan, Jean-
Christophe Martin, Sanjay Kamat, Michael See, Rajiv Chaudhury, Dinesh
Verma, George Powers, and Raj Yavatkar.
10. Security Considerations
o This document itself does not introduce any new security issues for a PolicyCondition "
"contained by one or more PolicyRules.")
]
CIM_PolicyCondition REF PartComponent;
[Description (
"Unsigned integer indicating the Internet, similar group to the circumstances which existed when SMI
was introduced. However, it is necessary to document the
requirements for a secure policy system, in order to show that "
"PolicyCondition identified by the
overall policy framework is viable. Our model for documenting
these requirements is based on prior work in ContainedCondition "
"property belongs. This integer segments the IETF on DNSSEC and
SNMPv3. One of our objectives in Conditions "
"into the policy work in ANDed sets (when the ConditionListType is "
"\"DNF\") or similarly the ORed sets (when the IETF Condition"
"ListType is to
not break the known existing security mechanisms, or to make them
less effective, regardless \"CNF\") that are then evaluated.")
]
uint16 GroupNumber;
[Description (
"Indication of whether or not these security
mechanisms affect what flows on the wire. Condition identified by "
"the ContainedCondition property is negated. TRUE "
"indicates that the PolicyCondition IS negated, FALSE "
"indicates that it IS NOT negated.")
]
boolean ConditionNegated;
};
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 52] 78]
Internet Draft Policy Core Information Model July October 2000
o Users: The first step in identifying security requirements for
policy, is to identify the users of policy. The users fall into
three categories:
o Administrators of Schema: This group requires the most stringent
authorization and associated security controls. An improper or
mal-formed change in the design of the policy schema carries with
it
// ==================================================================
// PolicyConditionInPolicyRepository
// ==================================================================
[Association, Description (
" A class representing the danger hosting of rendering the repository inoperable while the
repository reusable "
"PolicyConditions by a PolicyRepository. A reusable Policy"
"Condition is being repaired or re-built. During this time, the
policy enforcement entities would need to continue to enforce
policies according always related to their prior configuration. The good news is
that it is expected a single PolicyRepository, "
"via this aggregation.\n\n"
" "
"Note, that large network operators will change schema
design infrequently, and, when they do, the schema creation changes
will be tested on an off-line copy of the directory before the
operational directory is updated. Typically, a small group instance of
schema administrators will PolicyCondition can be authorized to make these changes in a
service provider either "
"reusable or enterprise environment. The ability to
maintain an audit trail is also required here.
o Administrators of Schema Content: This group requires authorization
to load values (entries) into a policy repository) schema
(read/write access). An audit trail mechanism rule-specific. When the Condition is also required
here. The effect of entering improperly formatted or maliciously-
intended data into a policy repository, could potentially result in
re-configuring mass numbers of network elements in a way that
renders them to be inoperable, or of rendering network resources
inaccessible for an extended period of time.
o Applications and PDPs: These entities must rule-"
"specific, it shall not be authorized for read-
only access related to any "
"PolicyRepository via the PolicyConditionInPolicyRepository "
"aggregation.")
]
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 policy repository, so that they may acquire
policy PolicyConditionInPolicyRepository "
"aggregation. The [0..1] cardinality for this property "
"covers the purposes two types of passing it to their respective
enforcement entities.
o Security Disciplines:
o Audit Trail (Non-repudiation): We document the need PolicyConditions: 0 for this
function in systems which maintain and distribute policy. The
dependency a "
"rule-specific PolicyCondition, 1 for support a reusable one.")
]
CIM_PolicyRepository REF Antecedent;
[Override ("Dependent"), Description (
"This property holds the name of this function is on a PolicyCondition"
"hosted in the implementers PolicyRepository. ")
]
CIM_PolicyCondition REF Dependent;
};
// ==================================================================
// 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 systems, and time periods, the "
"PolicyRule has no effect. A Rule is treated as valid "
"at ALL times, if it does not on any specific standards for
implementation. The requirement for specify a policy system is "
"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
minimum level of auditing via an auditing facility must be
provided. Logging should Rule was active might need to "
"be taken down when the Rule becomes inactive. In other "
"cases, however, such sessions might be enabled. This working group will
not specify what left up. In this minimal auditing function consists of.
o Access Control/Authorization: Access Control List (ACL)
functionality must be provided. The two administrative sets of
users documented above will form the basis for two
administrative use cases which require support.
o Authentication: Authentication support on "
"case, the order effect of that
available with TLS and Kerberos are acceptable for
authentication. We advise against using weaker mechanisms, deactivating the PolicyRule would "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 53] 79]
Internet Draft Policy Core Information Model July October 2000
such as clear text and HTTP Digest. Mutual authentication is
recommended.
o Integrity/Privacy: Integrity/privacy support on
"just be to prevent the order establishment of
TLS or IPSec is acceptable for encryption and data integrity new sessions. \n\n"
" "
"Setup / cleanup behaviors on validity period "
"transitions are not currently addressed by the wire. If physical Policy "
"Model, and must be specified in 'guideline' documents or virtual access "
"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
repository is in question, it may "
"administrator, then a mechanism to allow this control "
"must also be necessary to encrypt specified in the policy data subclasses.\n\n"
" "
"PolicyTimePeriodCondition is defined as it a subclass of "
"PolicyCondition. This is stored on to allow the file system; however,
specification inclusion of mechanisms for this purpose are outside "
"time-based criteria in the
scope AND/OR condition definitions "
"for a PolicyRule.\n\n"
" "
"Instances of this working group. In any case, we recommend that class may have up to five properties "
"identifying time periods at different levels. The values "
"of all the physical server be located properties present in a physically secure
environment.
In the case of PDP-to-PEP communications, an instance are ANDed "
"together to determine the use of IPSec is
recommended validity period(s) for providing confidentiality, data origin
authentication, integrity and replay prevention. See reference
[9].
o Denial of Service: We recommend the use "
"instance. For example, an instance with an overall "
"validity range of multiple policy
repositories, such 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 denial time "
"of day range of service attack on any one
repository will 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 make all policy data inaccessible to legitimate
users. However, this still leaves a denial of service attack
exposure. Our belief is that the use of a policy schema, present in a
centrally administered but physically distributed policy
repository, does not increase the risk of denial an instance of service
attacks; however, such attacks "
"PolicyTimePeriodCondition are still possible. If executed
successfully, such an attack could prevent PDPs from accessing a
policy repository, and thus prevent them from acquiring new policy.
In such a case, the PDPs, and associated PEPs would continue
operating under the policies implicitly treated as having "
"their value 'always enabled'. Thus, in force before the denial of service
attack was launched. Note that exposure of policy systems to
denial of service attacks example above, "
"the day-of-the-month mask is not any greater than the exposure of
DNS with DNSSEC in place.
11. References
[1] Distributed Management Task Force, Inc., "DMTF Technologies: CIM
Standards", available via links on the following DMTF web page:
http://www.dmtf.org/spec/cims.html.
[2] Distributed Management Task Force, Inc., "Common Information Model
(CIM) Specification, version 2.2, June 14, 1999. This document is
available on the following DMTF web page:
http://www.dmtf.org/spec/cims.html.
[3] Bradner, S., "Key words for use in RFCs to Indicate Requirement
Levels", BCP 14, RFC 2119, March 1997.
[4] Hovey, R., present, and S. Bradner, "The Organizations Involved in so the IETF
Standards Process", BCP 11, RFC 2028, October 1996.
Moore, et al. Expires: Jul 2000 + 6 months [Page 54]
Internet Draft Policy Core Information Model July 2000
[5] J. Strassner and S. Judd, "Directory-Enabled Networks", version
3.0c5 (August 1998). A PDF file is available at
http://www.murchiso.com/den/#denspec.
[6] J. Strassner, policy architecture BOF presentation, 42nd IETF
Meeting, Chicago, Illinois, October, 1998. Minutes of this BOF are
available at "
"validity period for the following location:
http://www.ietf.org/proceedings/98aug/index.html.
[7] Yergeau, F., "UTF-8, 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 transformation format second way to indicate that a Policy"
"Rule is always enabled: associate with it an instance of ISO 10646", RFC
2279, January 1998.
[8] Levi, D., and J. Schoenwaelder, "Definitions "
"PolicyTimePeriodCondition whose only properties with "
"specific values are its key properties.")
]
class CIM_PolicyTimePeriodCondition : CIM_PolicyCondition
{
[Description (
" This property identifies an overall range of Managed Objects for
Scheduling Management Operations", RFC 2591, May 1999.
[9] R. Yavatkar and D. Pendarakis, R. Guerin, "A Framework for Policy-
based Admission Control", RFC 2753, January 2000.
[10] Dawson, F., and D. Stenerson, "Internet Calendaring and Scheduling
Core Object Specification (iCalendar)", RFC 2445, November 1998.
[11] Strassner, J., and E. Ellesson, B. Moore, R. Moats, "Policy Core
LDAP Schema", draft-ietf-policy-core-schema-07.txt, July 2000.
12. Authors' Addresses
Ed Ellesson
Tivoli Systems
Building 10, Office R2D39
3901 Miami Blvd.
Durham, NC 27703
Phone: +1 919-224-2111
Fax: +1 919-224-2540
E-mail: ed_ellesson@tivoli.com
Bob Moore
IBM Corporation, BRQA/502
4205 S. Miami Blvd.
Research Triangle Park, NC 27709
Phone: +1 919-254-4436
Fax: +1 919-254-6243
E-mail: remoore@us.ibm.com
John Strassner
Cisco Systems, Bldg 15
170 West Tasman Drive
San Jose, CA 95134
Phone: +1 408-527-1069
Fax: +1 408-527-6351
E-mail: johns@cisco.com
Andrea Westerinen calendar "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 55] 80]
Internet Draft Policy Core Information Model July October 2000
Cisco Systems
170 West Tasman Drive
San Jose, CA 95134
Phone: +1 408-853-8294
Fax: +1 408-527-6351
E-mail: andreaw@cisco.com
13. Full Copyright Statement
Copyright (C) The Internet Society (2000). All Rights Reserved.
This document
"dates and translations 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 it may be copied the "
"time portion, followed by the solidus character '/', "
"followed by a similar string representing an end date and furnished to
others, "
"time. The first date indicates the beginning of the range, "
"while the second date indicates the end. Thus, the second "
"date and derivative works that comment on or otherwise explain it
or assist in its implementation may time must be prepared, copied, published and
distributed, in whole or 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 part, without restriction which one of any kind,
provided 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 above copyright notice and this paragraph are
included 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 all such copies the date/time that "
" appears before the '/', and derivative works. However, 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
document itself may not be modified in any way, such as property is to refine the valid time "
"period that is defined by removing the copyright notice or references 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 Internet Society or other
Internet organizations, except Rule is valid.\n\n"
" "
"This property is formatted as needed for an octet string, structured "
"as follows:\n"
" o a 4-octet length field, indicating the purpose length of developing
Internet standards in which case the procedures "
" entire octet string; this field is always set to "
" 0x00000006 for copyrights defined
in this property;\n"
" o a 2-octet field consisting of 12 bits identifying the Internet Standards process must be followed, or as required to
translate it into languages other than English.
The limited permissions granted above are perpetual "
" 12 months of the year, beginning with January and will not be
revoked "
" ending with December, followed by 4 bits that are "
" always set to '0'. For each month, the Internet Society or its successors or assigns.
This document and value '1' "
" indicates that the information contained herein policy is provided on an
"AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN
WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. valid for that month, "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 56] 81]
Internet Draft Policy Core Information Model July October 2000
14. Appendix A - Class Identification in a Native CIM Implementation
While the CommonName property is present in the abstract superclass
Policy,
" and the value '0' indicates that it is thus available in all of its instantiable subclasses,
CIM does not use this property valid.\n\n"
" "
"The value 0x000000060830, for naming instances. The following
subsections discuss how naming is handled in example, indicates that a native CIM
implementation for each of the instantiable classes "
"PolicyRule is valid only in the Policy Core
Information Model.
Two things should be noted regarding CIM naming:
o When months May, November, "
"and December.\n\n"
" "
"If a CIM association is specified as "weak", value for this property is a statement
about naming scopes: an instance of the class at the weak end of not provided, then the association "
"PolicyRule is named within the scope of an instance of the
class at treated as valid for all twelve months, and "
"only restricted by its TimePeriod property value and the other end "
"other Mask properties."),
ModelCorrespondence {
"CIM_PolicyTimePeriodCondition.TimePeriod",
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"}
]
uint8 MonthOfYearMask[];
[Octetstring, Description (
" The purpose of this property is to refine the association. This valid time "
"period that is accomplished defined by
propagation of keys from the instance TimePeriod property, by "
"explicitly specifying in which days of the scoping class to the
instance of month the weak class. Thus Policy"
"Rule is valid. These properties work together, "
"with the weak class has, via key
propagation, all TimePeriod used to specify the keys from overall time period "
"in which the scoping class, PolicyRule is valid, and it also has
one or more additional keys for distinguishing instances of the
weak class, within DayOfMonthMask used "
"to pick out the context days of the scoping class.
o All class names in CIM are limited to alphabetic and numeric
characters plus month during which the underscore, with 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 restriction that length of the first
character cannot be numeric. Refer "
" entire octet string; this field is always set to Appendix F "Unicode Usage"
in reference [2] "
" 0x0000000C for this property; \n"
" o an exact specification of how CIM class names
are encoded in CIM strings.
14.1. Naming Instances 8-octet field consisting of 31 bits identifying "
" the days of PolicyGroup and PolicyRule
A policy group always exists in the context month counting from the beginning, "
" followed by 31 more bits identifying the days of a system. In the
Policy Core Information Model, this is captured "
" month counting from the end, followed by 2 bits that "
" are always set to '0'. For each day, the weak
aggregation PolicyGroupInSystem between a PolicyGroup and a System.
Note value '1' "
" indicates that System serves as the base class policy is valid for describing network
devices that day, and administrative domains.
A policy rule also exists in the context of a system. In "
" the Policy
Core Information Model, this value '0' indicates that it is captured by the weak association
PolicyRuleInSystem between not valid. \n\n"
" "
"The value 0x0000000C8000000100000000, for example, "
"indicates that a PolicyRule and a System.
The following sections define is valid on the CIM keys for PolicyGroup first and
PolicyRule.
14.1.1. PolicyGroup's CIM Keys
The CIM keys "
"last days of the PolicyGroup class are:
o SystemCreationClassName (A CIM_System key, propagated due to month.\n\n "
" "
"For months with fewer than 31 days, the
weak association, PolicyGroupInSystem)
o SystemName (A CIM_System key, propagated due to digits corresponding "
"to days that the weak
association, PolicyGroupInSystem)
o CreationClassName
o PolicyGroupName
Moore, et al. Expires: Jul 2000 + 6 months [Page 57]
Internet Draft Policy Core Information Model July 2000
They are defined do not have (counting in Reference [1] as follows:
NAME SystemCreationClassName
DESCRIPTION SystemCreationClassName represents the class name
of the CIM System object providing the naming scope both "
"directions) are ignored.\n\n"
" "
"If a value for this property is not provided, then the instance of PolicyGroup.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME SystemName
DESCRIPTION SystemName represent the individual name of the
particular System object, providing the naming
scope "
"PolicyRule is treated as valid for all days of the instance month, and "
"only restricted by its TimePeriod property value and the "
"other Mask properties."),
ModelCorrespondence {
"CIM_PolicyTimePeriodCondition.TimePeriod",
Moore, et al. Expires: Oct 2000 + 6 months [Page 82]
Internet Draft Policy Core Information Model October 2000
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"}
]
uint8 DayOfMonthMask[];
[Octetstring, Description (
" The purpose of PolicyGroup.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION This this property is set to "CIM_PolicyGroup", if refine the
PolicyGroup object is directly instantiated. Or,
it valid time "
"period that is equal to defined by the class name TimePeriod property, by "
"explicitly specifying in which days of the PolicyGroup
subclass that month the Policy"
"Rule is instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyGroupName
DESCRIPTION The identifying name of this policy group.
SYNTAX string [MaxLen 256]
QUALIFIER key
14.1.2. PolicyRule's CIM Keys
The CIM keys of valid. These properties work together, "
"with the PolicyRule class are:
o SystemCreationClassName (A CIM_System key, propagated due TimePeriod used to specify the
weak association PolicyRuleInSystem)
o SystemName (A CIM_System key, propagated due to overall time period "
"in which the weak
association PolicyRuleInSystem)
o CreationClassName
o PolicyRuleName
SystemCreationClassName PolicyRule is valid, and SystemName work the same as defined for DayOfWeekMask used "
"to pick out the class PolicyGroup. See Section 14.1.1 for details.
The other two properties are defined in Reference [1] as follows:
NAME CreationClassName
DESCRIPTION This 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 "CIM_PolicyRule", if "
" 0x00000005 for this property;\n"
" o a 1-octet field consisting of 7 bits identifying the
PolicyRule object is directly instantiated. Or, it 7 "
" days of the week, beginning with Sunday and ending with "
" Saturday, followed by 1 bit that is equal always set to the class name '0'. "
" For each day of the PolicyRule
subclass week, the value '1' indicates that "
" the policy is instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
Moore, et al. Expires: Jul 2000 + 6 months [Page 58]
Internet Draft Policy Core Information Model July 2000
NAME PolicyRuleName
DESCRIPTION The identifying name of 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 policy rule.
SYNTAX string [MaxLen 256]
QUALIFIER key
14.2. Naming Instances property is not provided, then the "
"PolicyRule is treated as valid for all days of PolicyCondition the week, "
"and only restricted by its TimePeriod property value and Its Subclasses "
"the other Mask properties."),
ModelCorrespondence {
"CIM_PolicyTimePeriodCondition.TimePeriod",
"CIM_PolicyTimePeriodCondition.LocalOrUtcTime"}
]
uint8 DayOfWeekMask[];
[Description (
" The CIM keys purpose of this property is to refine the PolicyCondition class are:
o SystemCreationClassName
o SystemName
o PolicyRuleCreationClassName
o PolicyRuleName
o CreationClassName
o PolicyConditionName
Note valid time "
"period that none 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 keys are defined as propagated, although they
appear TimePeriod used to fit this convention. The reason for this difference is
because (as indicated specify the overall "
"time period in Sections 5.1 and 6.4) which the PolicyCondition
class PolicyRule is valid, and the "
"TimeOfDayMask used to represent both reusable and rule-specific conditions.
This, in turn, affects what associations are valid for an instance pick out the range of
PolicyCondition, and how that instance time periods "
"in a given day of during which the Rule is named.
In an ideal world, an instance valid. \n\n"
" "
"This property is formatted in the style of RFC 2445: a "
"time string beginning with the PolicyCondition class would be
scoped either character 'T', followed by its PolicyRepository (for a reusable condition) or "
"the solidus character '/', followed by
its PolicyRule (for a rule-specific condition). However, CIM has second time string. "
"The first time indicates the
restriction that beginning of the range, while "
"the second time indicates the end. Times are expressed as "
Moore, et al. Expires: Oct 2000 + 6 months [Page 83]
Internet Draft Policy Core Information Model October 2000
"substrings of the form 'Thhmmss'. \n\n"
" "
"The second substring always identifies a given class can only be "weak" to one other class
(i.e., defined by one weak association). later time than "
"the first substring. To work within allow for ranges that span "
"midnight, however, the restrictions value of CIM naming, it is necessary to
"simulate" weak associations between PolicyCondition and PolicyRule,
and between PolicyCondition and PolicyRepository, through 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 technique
we'll call manual key propagation. Strictly speaking, manual key
propagation isn't key propagation at all. But range spans midnight, it has by definition includes "
"parts of two successive days. When one of these days is "
"also selected by either the same effect
as (true) key propagation, so MonthOfYearMask, "
"DayOfMonthMask, and/or DayOfWeekMask, but the name fits.
Figure 9 illustrates how manual propagation works in other day is "
"not, then the case of
PolicyCondition. (Note that policy is active only during the key properties are shown for each portion of "
"the range that falls on the classes.) In the figure, selected day. For example, if "
"the range extends from 2100 until 0800, and the line composed day of 'I's indicates
class inheritance, "
"week mask selects Monday and Tuesday, then the one composed of 'P's indicates (true) key
propagation via policy is "
"active during the weak aggregation PolicyRuleInSystem, and 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 ones
composed of 'M's indicate manual key propagation.
Moore, et al. Expires: Jul 2000 + 6 months [Page 59]
Internet Draft Policy Core Information Model July 2000
+------------------+
| System |
+------------------+
|CreationClassName |
|Name |
+------------------+
^ P
I PPPPPPPPPPPPPPPPPPPPPPPPPPPP
I P
+------------------+ +---------------v--------------+
| AdminDomain | | PolicyRule |
+------------------+ +------------------------------+
|CreationClassName | | System.CreationClassName |
|Name | | System.Name |
+------------------+ | CreationClassName |
^ | PolicyRuleName |
I +------------------------------+
I M
I M
+------------------+ M
| PolicyRepository | M
+------------------+ M
|CreationClassName | M
|Name | M
+------------------+ M
M M
M M
M M
+----v-------------------v----+
| PolicyCondition |
+-----------------------------+
| SystemCreationClassName |
| SystemName |
| PolicyRuleCreationClassName |
| PolicyRuleName |
| CreationClassName |
| PolicyConditionName |
+-----------------------------+
Figure 9. Manual Key Propagation "
"PolicyRule is treated as valid for Naming PolicyConditions
Looking at Figure 9, we see that two key properties, CreationClassName
and Name, are defined in all hours of the System class, and inherited day, "
"and only restricted by its
subclasses AdminDomain TimePeriod property value and PolicyRepository. Since PolicyRule is weak
to System, these two keys are propagated to it; it also has its own
keys CreationClassName "
"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 PolicyRuleName.
A similar approach, though not automatic, is used in "manual key
propagation." Here is the approach various Mask "
"properties represent local times or UTC times. There is "
"no provision for rule-specific mixing of local times and reusable
PolicyConditions: 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;
};
// ==================================================================
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 60] 84]
Internet Draft Policy Core Information Model July October 2000
o The manual propagation of keys from PolicyRule to PolicyCondition
involves copying the values of PolicyRule's four key properties
into four similarly named key properties in PolicyCondition. From
the point of view
// PolicyRuleValidityPeriod
// ==================================================================
[Association, Aggregation, Description (
"The PolicyRuleValidityPeriod aggregation represents "
"scheduled activation and deactivation of the CIM specification language, the property
SystemName in PolicyCondition is a completely new key property.
However, the relationship to the Name property in System is defined
in the description of SystemName.
o The manual propagation of keys from PolicyRepository to
PolicyCondition works in exactly the same way for the first two key
properties. However, since PolicyRepository doesn't include PolicyRule. "
"If a PolicyRule properties, the PolicyRuleCreationClassName and
PolicyRuleName have no values. A special value, "No Rule", is
assigned to both of these properties in this case, indicating that
this instance of PolicyCondition is not named within the scope of
any particular policy rule.
The following section defines the specific CIM keys for
PolicyCondition.
14.2.1. PolicyCondition's CIM Keys
PolicyCondition's key properties are defined in Reference [1] as
follows:
NAME SystemCreationClassName
DESCRIPTION SystemCreationClassName represents the class name
of the CIM System object providing the naming scope
for the instance of PolicyCondition. For a rule-
specific associated with multiple policy condition, time "
"periods via this is the type of
system (e.g., association, then the name Rule is active if "
"at least one of the class time periods indicates that created
this instance) in whose context the policy rule is
defined. For a reusable policy condition, this it is
set "
"active. (In other words, the PolicyTimePeriodConditions "
"are ORed to "CIM_PolicyRepository", if determine whether the
PolicyRepository object is directly instantiated.
Or, it Rule is equal 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 class name point of the
PolicyRepository subclass that is instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME SystemName
DESCRIPTION The name view of scheduling, "
"always active. It may, however, be inactive for other "
"reasons. For example, the System object in whose scope this
policy condition is defined. This Rule's Enabled property
completes may "
"be set to \"disabled\" (value=2).")
]
class CIM_PolicyRuleValidityPeriod : CIM_PolicyComponent
{
[Override ("GroupComponent"), Aggregate, Description (
"This property contains the identification name of the System object.
For a rule-specific policy condition, this is PolicyRule that "
"contains one or more PolicyTimePeriodConditions.")
]
CIM_PolicyRule REF GroupComponent;
[Override ("PartComponent"), Description (
"This property contains the name of a "
"PolicyTimePeriodCondition defining the instance of valid time periods "
"for one or more PolicyRules.")
]
CIM_PolicyTimePeriodCondition REF PartComponent;
};
// ==================================================================
// VendorPolicyCondition
// ==================================================================
[Description (
" A class that provides a general extension mechanism for "
"representing PolicyConditions that have not been modeled "
"with specific properties. Instead, the system in whose context two properties "
"Constraint and ConstraintEncoding are used to define the policy rule is defined. For a reusable policy
condition, this is name "
"content and format of the instance of
PolicyRepository that holds Condition, as explained below.\n\n"
" "
"As its name suggests, VendorPolicyCondition is intended for "
"vendor-specific extensions to the policy condition.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleCreationClassName 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 "
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 61] 85]
Internet Draft Policy Core Information Model July October 2000
DESCRIPTION For a rule-specific policy condition, this property
identifies the class name
"modeled with specific properties. The format of the policy rule
instance, "
"octet strings in whose scope this instance of
PolicyCondition exists. For a reusable policy
condition, this the array is left unspecified in "
"this definition. It is determined by the OID value "
"stored in the property ConstraintEncoding. Since "
"ConstraintEncoding is set to a special value,
"No Rule", indicating that this instance single-valued, all the values of
PolicyCondition is not unique to one policy rule.
SYNTAX "
"Constraint share the same format and semantics."),
ModelCorrespondence {
"CIM_VendorPolicyCondition.ConstraintEncoding"}
]
string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleName
DESCRIPTION For Constraint [];
[Description (
"An OID encoded as a rule-specific policy condition,
PolicyRuleName completes the identification of string, identifying the
PolicyRule object with which format "
"and semantics for this condition is
associated. For instance's Constraint property."),
ModelCorrespondence {
"CIM_VendorPolicyCondition.Constraint"}
]
string ConstraintEncoding;
};
// ==================================================================
// PolicyAction
// ==================================================================
[Abstract, Description (
"A class representing a rule-specific or reusable policy condition, "
"action to be performed if the PolicyConditions for a
special value, "No Rule", is used Policy"
"Rule evaluate to indicate that TRUE. Since all operational details of a "
"PolicyAction are provided in subclasses of this condition object, "
"this class is reusable.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION The abstract.")
]
class CIM_PolicyAction : CIM_Policy
{
[Key, MaxLen (256), Description (
" The name of the PolicyCondition class or the subclass that
is instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER key
NAME PolicyConditionName
DESCRIPTION The identifying name used in the "
"creation of the System object in whose scope this policy condition.
SYNTAX string [MaxLen 256]
QUALIFIER key
14.3. Naming Instances "
"PolicyAction is defined. \n\n"
" "
"This property helps to identify the System object in "
"whose scope this instance of PolicyAction and Its Subclasses
From exists. "
"For a rule-specific PolicyAction, this is the System "
"in whose context the PolicyRule is defined. For a "
"reusable PolicyAction, this is the point instance of view "
"PolicyRepository (which is a subclass of naming, the PolicyAction class and its
subclasses work exactly like System) that "
"holds the PolicyCondition class and its
subclasses. See Section 14.2 Action. \n\n"
" "
"Note that this property, and 14.2.1 for details.
Specifically, the CIM analogous property "
"SystemName, do not represent propagated keys from an "
"instance of PolicyAction are:
o SystemCreationClassName
o SystemName
o PolicyRuleCreationClassName
o PolicyRuleName
o CreationClassName
o PolicyActionName
They the class System. Instead, they are "
"properties defined in Reference [1] as follows:
NAME SystemCreationClassName
DESCRIPTION SystemCreationClassName represents the class name context of this class, which "
"repeat the CIM System object providing the naming scope
for values from the instance of PolicyAction. For a rule-
specific policy action, this System to which "
"this PolicyAction is related, either directly via the type of system "
"PolicyActionInPolicyRepository aggregation or indirectly "
"via the PolicyActionInPolicyRule aggregation.")
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 62] 86]
Internet Draft Policy Core Information Model July October 2000
(e.g., the name of the class that created this
instance) in whose context the policy rule is
defined. For a reusable policy action, this is set
to "CIM_PolicyRepository", if the PolicyRepository
object is directly instantiated. Or, it is equal
to the class name of the PolicyRepository subclass
that is instantiated.
SYNTAX
]
string [MaxLen 256]
QUALIFIER key
NAME SystemName
DESCRIPTION SystemCreationClassName;
[Key, MaxLen (256), Description (
" The name of the System object in whose scope this
policy action "
"PolicyAction is defined. This \n\n"
" "
"This property completes the identification of the System object. "
"object in whose scope this instance of PolicyAction "
"exists. For a rule-specific policy action, PolicyAction, this is the name of
the instance of the system "
"System in whose context the
policy rule PolicyRule is defined. For a "
"a reusable policy
action, PolicyAction, this is name of the instance of
PolicyRepository "
"PolicyRepository (which is a subclass of System) that holds "
"holds the policy action.
SYNTAX Action.")
]
string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleCreationClassName
DESCRIPTION For SystemName;
[Key, MaxLen (256), Description (
"For a rule-specific policy action, this property
identifies PolicyAction, the class name of CreationClassName "
"of the policy rule
instance, in whose scope this instance of
PolicyAction exists. For a reusable policy action, PolicyRule object with which this property Action is set to "
"associated. For a special reusable PolicyAction, a "
"special value, "No Rule",
indicating 'NO RULE', should be used to "
"indicate that this instance of PolicyAction Action is reusable and not unique to one policy rule.
SYNTAX "
"associated with a single PolicyRule.")
]
string [MaxLen 256]
QUALIFIER key
NAME PolicyRuleName
DESCRIPTION For PolicyRuleCreationClassName;
[Key, MaxLen (256), Description (
"For a rule-specific policy action, PolicyRuleName
completes PolicyAction, the identification name of the "
"the PolicyRule object with which this action Action is associated. "
"associated. For a reusable policy action, PolicyAction, a special "
"special value, "No Rule",
is 'NO RULE', should be used to indicate "
"indicate that this action Action is reusable.
SYNTAX reusable and not "
"associated with a single PolicyRule.")
]
string [MaxLen 256]
QUALIFIER key
NAME CreationClassName
DESCRIPTION The class PolicyRuleName;
[Key, MaxLen (256), Description (
"CreationClassName indicates the name of the PolicyAction subclass that is
instantiated.
SYNTAX string [MaxLen 256]
QUALIFIER class or the "
"subclass used in the creation of an instance. When used "
"with the other key
NAME PolicyActionName
DESCRIPTION The identifying 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 policy action.
SYNTAX PolicyAction.")
]
string [MaxLen 256]
QUALIFIER key PolicyActionName;
};
// ==================================================================
// PolicyActionInPolicyRepository
// ==================================================================
[Association, Description (
" A class representing the hosting of reusable "
"PolicyActions by a PolicyRepository. A reusable Policy"
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 63] 87]
Internet Draft Policy Core Information Model July October 2000
14.4. Naming Instances of PolicyRepository
An instance of PolicyRepository
"Action is named by the two key properties
CreationClassName and Name always related to a single PolicyRepository, "
"via this aggregation.\n\n"
" "
"Note, that it inherits from its superclass
AdminDomain. These properties are actually defined in AdminDomain's
superclass, System, and then inherited by AdminDomain.
For instances an instance of PolicyRepository itself, PolicyAction can be either "
"reusable or rule-specific. When the value of
CreationClassName must Action is rule-"
"specific, it shall not be "CIM_PolicyRepository". (Recall that for
readability related to any "
"PolicyRepository via the prefix "CIM_" has been omitted from all PolicyActionInPolicyRepository "
"aggregation.")
]
class names in
this document). If CIM_PolicyActionInPolicyRepository : CIM_PolicyInSystem
{
[Override ("Antecedent"), Max(1), Description (
"This property represents a subclass of PolicyRepository (perhaps
QosPolicyRepository) "
"hosting one or more PolicyActions. A reusable "
"PolicyAction is defined and instantiated, then always related to exactly one "
"PolicyRepository via the class name
"CIM_QosPolicyRepository" is used in CreationClassName. PolicyActionInPolicyRepository "
"aggregation. The Name [0..1] cardinality for this property simply completes "
"covers the identification 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 instance name of a PolicyAction"
"hosted in the PolicyRepository.
14.5. Role ")
]
CIM_PolicyAction REF Dependent;
};
// ==================================================================
// PolicyActionInPolicyRule
// ==================================================================
[Association, Aggregation, Description (
" A PolicyRule aggregates zero or more instances of the CreationClassName Property "
"PolicyAction class, via the PolicyActionInPolicyRule "
"association. A Rule that aggregates zero Actions is not "
"valid -- it may, however, be in Naming
To provide the process of being entered "
"into a PolicyRepository or being defined for more flexibility a System. "
"Alternately, the actions of the policy may be explicit in instance naming, CIM makes use "
"the definition of the PolicyRule. Note that a
property called CreationClassName. The idea of CreationClassName PolicyRule "
"should have no effect until it is
to provide another dimension that 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 PolicyActionIn"
"PolicyRule aggregation can be used to avoid naming
collisions, in the specific case of instances belonging to two
different subclasses of express an order. \n\n"
" "
"This aggregation does not indicate whether a common superclass. An example will
illustrate how CreationClassName works.
Suppose we have instances specified "
"action order is required, recommended, or of two different subclasses no significance; "
"the property SequencedActions in the aggregating instance of
PolicyCondition, FrameRelayPolicyCondition and BgpPolicyCondition, and
that these instances apply to "
"PolicyRule provides this indication.")
]
class CIM_PolicyActionInPolicyRule : CIM_PolicyComponent
Moore, et al. Expires: Oct 2000 + 6 months [Page 88]
Internet Draft Policy Core Information Model October 2000
{
[Override ("GroupComponent"), Aggregate, Description (
"This property represents the same context. If we had only PolicyRule that "
"contains one or more PolicyActions.")
]
CIM_PolicyRule REF GroupComponent;
[Override ("PartComponent"), Description (
"This property holds the
single key name of a PolicyAction "
"contained by one or more PolicyRules.")
]
CIM_PolicyAction REF PartComponent;
[Description (
" This property PolicyConditionName available for distinguishing provides an unsigned integer 'n' that"
"indicates the two instances, then relative position of a collision would result from naming both PolicyAction in the "
"sequence of actions associated with a PolicyRule. "
"When 'n' is a positive integer, it indicates a place "
"in the instances sequence of actions to be performed, with "
"smaller integers indicating earlier positions in the key "
"sequence. The special value PCName = "PC-1". Thus policy
administrators from widely different disciplines would '0' indicates 'don't care'. "
"If two or more PolicyActions have to
coordinate their naming 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 PolicyConditions for this context.
With CreationClassName, collisions examples will make ordering of this type can be eliminated,
without requiring coordination among PolicyActions "
"clearer: \n"
" o If all actions have the policy administrators. same sequence number, "
" regardless of whether it is '0' or non-zero, any "
" 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 instances acceptable orders: A,C,B,D or C,A,B,D, "
" since A and C can be distinguished by giving their CreationClassNames
different values. One instance is now identified with performed in either order, but "
" only at the two keys
CreationClassName = "FrameRelayPolicyCondition" + PCName = "PC-1",
while '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 "
" B,D,C. Action A may appear at any point relative to "
" B, C, and D. Thus the other is identified with
CreationClassName = "BgpPolicyCondition" + PCName = "PC-1".
Each complete set of acceptable "
" orders is: A,B,C,D; B,A,C,D; B,C,A,D; B,C,D,A; "
" A,B,D,C; B,A,D,C; B,D,A,C; B,D,C,A. \n\n"
" "
"Note that the instantiable classes in the Core Model includes the
CreationClassName property as a key in addition to its own class-
specific key property. non-zero sequence numbers need not start "
"with '1', and they need not be consecutive. All that "
"matters is their relative magnitude.")
]
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 64] 89]
Internet Draft Policy Core Information Model July October 2000
14.6. Object References
Today, all CIM associations involve two object references. CIM
decomposes an object reference into two parts: a high-order part that
identifies an object manager and namespace, and a model path that
identifies an object instance within a namespace. The model path, in
turn, can be decomposed into an object class identifier and a set of
key values needed to identify an instance of that class.
Because the object class identifier is part of the model path, a CIM
object reference is strongly typed. The GroupComponent object
reference in the PolicyGroupInPolicyGroup association, for example,
can only point to an instance of PolicyGroup, or to an instance of a
subclass of PolicyGroup. Contrast this with LDAP, where a DN pointer
is completely untyped: it identifies (by DN) an entry, but places no
restriction on that entry's object class(es).
An important difference between CIM property definitions and LDAP
attribute type definitions was identified earlier in Section 6: while
an LDAP attribute type definition has global scope, a CIM property
definition applies only to the class in which it is defined. Thus
properties having
uint16 ActionOrder;
};
// ==================================================================
// VendorPolicyAction
// ==================================================================
[Description (
" A class that provides a general extension mechanism for "
"representing PolicyActions that have not been modeled "
"with specific properties. Instead, the same name in two different classes properties "
"ActionData and ActionEncoding are free used to
have different data types. CIM takes advantage of this flexibility by
allowing define the data type of an object reference to be overridden in a
subclass "
"content and format of the association class in which it was initially defined.
For example, the object reference GroupComponent Action, as explained below.\n\n"
" "
"As its name suggests, VendorPolicyAction is defined in intended for "
"vendor-specific extensions to the
abstract aggregation class PolicyComponent Policy Core Information "
"Model. Standardized extensions are not expected to be use "
"this class.") ]
class CIM_VendorPolicyAction : CIM_PolicyAction
{
[Octetstring, Description (
"This property provides a reference to an
instance general extension mechanism for "
"representing PolicyActions that have not been "
"modeled with specific properties. The format of the class Policy. This data type for GroupComponent is
then overridden "
"octet strings in subclasses of PolicyComponent. In
PolicyGroupInPolicyGroup, for example, GroupComponent becomes a
reference to an instance of PolicyGroup. But the array is left unspecified in
PolicyConditionInPolicyRule it becomes a reference to an instance of
PolicyRule. Of course there "
"this definition. It is not total freedom determined by the OID value "
"stored in this overriding
of object references. In order to remain consistent with its abstract
superclass, a subclass the property ActionEncoding. Since "
"ActionEncoding is single-valued, all the values of PolicyComponent can only override
GroupComponent to be a reference to "
"ActionData share the same format and semantics."),
ModelCorrespondence {
"CIM_VendorPolicyAction.ActionEncoding"}
]
string ActionData [];
[Description (
"An OID encoded as a subclass of Policy. A Policy
class is string, identifying the generic context format "
"and semantics for the GroupComponent reference in
PolicyComponent. this instance's ActionData property."),
ModelCorrespondence {
"CIM_VendorPolicyAction.ActionData"}
]
string ActionEncoding;
};
// ===================================================================
// end of file
// ===================================================================
Moore, et al. Expires: Jul Oct 2000 + 6 months [Page 65] 90]
----