|
Network Working Group Request for Comments: 3060 Category: Standards Track |
B. Moore IBM E. Ellesson LongBoard, Inc. J. Strassner A. Westerinen Cisco Systems February 2001 |
This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited.
Copyright © The Internet Society (2001). All Rights Reserved.
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.
1. Introduction
2. Modeling Policies
2.1. Policy Scope
2.2. Declarative versus Procedural Model
3. Overview of the Policy Core Information Model
4. Inheritance Hierarchies for the Policy Core Information Model.. 13
4.1. Implications of CIM Inheritance
5. Details of the Model
5.1. Reusable versus Rule-Specific Conditions and Actions
5.2. Roles
5.2.1. Roles and Role Combinations
5.2.2. The PolicyRoles Property
5.3. Local Time and UTC Time in PolicyTimePeriodConditions
5.4. CIM Data Types
5.5. Comparison between CIM and LDAP Class Specifications
6. Class Definitions
6.1. The Abstract Class "Policy"
6.1.1. The Property "CommonName (CN)"
6.1.2. The Multi-valued Property "PolicyKeywords"
6.1.3. The Property "Caption" (Inherited from ManagedElement).. 27
6.1.4. The Property "Description" (Inherited from
ManagedElement)
6.2. The Class "PolicyGroup"
6.3. The Class "PolicyRule"
6.3.1. The Property "Enabled"
6.3.2. The Property "ConditionListType"
6.3.3. The Property "RuleUsage"
6.3.4. The Property "Priority"
6.3.5. The Property "Mandatory"
6.3.6. The Property "SequencedActions"
6.3.7. The Multi-valued Property "PolicyRoles"
6.4. The Abstract Class "PolicyCondition"
6.5. The Class "PolicyTimePeriodCondition"
6.5.1. The Property "TimePeriod"
6.5.2. The Property "MonthOfYearMask"
6.5.3. The Property "DayOfMonthMask"
6.5.4. The Property "DayOfWeekMask"
6.5.5. The Property "TimeOfDayMask"
6.5.6. The Property "LocalOrUtcTime"
6.6. The Class "VendorPolicyCondition"
6.6.1. The Multi-valued Property "Constraint"
6.6.2. The Property "ConstraintEncoding"
6.7. The Abstract Class "PolicyAction"
6.8. The Class "VendorPolicyAction"
6.8.1. The Multi-valued Property "ActionData"
6.8.2. The Property "ActionEncoding"
6.9. The Class "PolicyRepository"
7. Association and Aggregation Definitions
7.1. Associations
7.2. Aggregations
7.3. The Abstract Aggregation "PolicyComponent
7.4. The Aggregation "PolicyGroupInPolicyGroup"
7.4.1. The Reference "GroupComponent"
7.4.2. The Reference "PartComponent"
7.5. The Aggregation "PolicyRuleInPolicyGroup"
7.5.1. The Reference "GroupComponent"
7.5.2. The Reference "PartComponent"
7.6. The Aggregation "PolicyConditionInPolicyRule"
7.6.1. The Reference "GroupComponent"
7.6.2. The Reference "PartComponent"
7.6.3. The Property "GroupNumber"
7.6.4. The Property "ConditionNegated"
7.7. The Aggregation "PolicyRuleValidityPeriod"
7.7.1. The Reference "GroupComponent"
7.7.2. The Reference "PartComponent"
7.8. The Aggregation "PolicyActionInPolicyRule"
7.8.1. The Reference "GroupComponent"
7.8.2. The Reference "PartComponent"
7.8.3. The Property "ActionOrder"
7.9. The Abstract Association "PolicyInSystem"
7.10. The Weak Association "PolicyGroupInSystem"
7.10.1. The Reference "Antecedent"
7.10.2. The Reference "Dependent"
7.11. The Weak Association "PolicyRuleInSystem"
7.11.1. The Reference "Antecedent"
7.11.2. The Reference "Dependent"
7.12. The Association "PolicyConditionInPolicyRepository"
7.12.1. The Reference "Antecedent"
7.12.2. The Reference "Dependent"
7.13. The Association "PolicyActionInPolicyRepository"
7.13.1. The Reference "Antecedent"
7.13.2. The Reference "Dependent"
7.14. The Aggregation "PolicyRepositoryInPolicyRepository"
7.14.1. The Reference "GroupComponent"
7.14.2. The Reference "PartComponent"
8. Intellectual Property
9. Acknowledgements
10. Security Considerations
11. References
12. Authors' Addresses
13. Appendix A: Class Identification in a Native CIM
Implementation
13.1. Naming Instances of PolicyGroup and PolicyRule
13.1.1. PolicyGroup's CIM Keys
13.1.2. PolicyRule's CIM Keys
13.2. Naming Instances of PolicyCondition and Its Subclasses... 67
13.2.1. PolicyCondition's CIM Keys
13.3. Naming Instances of PolicyAction and Its Subclasses
13.4. Naming Instances of PolicyRepository
13.5. Role of the CreationClassName Property in Naming
13.6. Object References
14. Appendix B: The Core Policy MOF
15. Full Copyright Statement
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 components of the CIM schema are available via the following URL: http://www.dmtf.org/spec/cims.html [1].
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:
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].
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 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,
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.
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 specifications. The Policy Core Information Model classes are intended to serve as the foundation for these lower-level, vendor- and device-independent specifications.
It is envisioned that the definition of the Policy Core Informational Model in this document 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.).
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 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.
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 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.
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.
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".
+-----------+
| 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 (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:
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.
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, 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:
[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
The Dependency, Component, and SystemComponent associations are defined in the CIM schema [1], and are not discussed further in this document.
From the CIM schema, both properties and associations are inherited to the Policy classes. For example, the class ManagedElement is referenced in the associations Dependency, Statistics and MemberOfCollection. And, the Dependency association is in turn referenced in the DependencyContext association. At this very abstract and high level in the 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 Core Information Model. In fact, they are defined as OPTIONAL in the CIM Schema - since their cardinality is "0..n" on all references. The PCIM document specifically discusses what is necessary to support and instantiate. For example, through subclassing of the Dependency association, the exact Dependency semantics in PCIM are described.
So, one may wonder what to do with these other inherited
associations. The answer is "ignore them unless you need them". You
would need them to describe additional information and semantics for
policy data. For example, it may be necessary to capture statistical
data for a PolicyRule (either for the rule in a repository or for
when it is executing in a policy system). Some examples of
statistical data for a rule are the number of times it was
downloaded, the number of times its conditions were evaluated, and
the number of times its actions were executed. (These types of data
would be described in a subclass of CIM_StatisticalInformation.) In
these cases, the Statistics association inherited from ManagedElement
to PolicyRule may be used to describe the tie between an instance of
a PolicyRule and the set of statistics for it.
The following subsections discuss several specific issues related to the Policy Core Information Model.
Policy conditions and policy actions can be partitioned into two groups: ones associated with a single policy rule, and ones that are reusable, in the sense that they may be associated with more than one policy rule. Conditions and actions in the first group are termed "rule-specific" conditions and actions; those in the second group are characterized as "reusable".
It is important to understand that the difference between a rule- specific condition or action and a reusable one is based on the intent of the policy administrator for the condition or action, rather than on the current associations in which the condition or action participates. Thus a reusable condition or action (that is, one that a policy administrator has created to be reusable) may at some point in time be associated with exactly one policy rule, without thereby becoming rule-specific.
There is no inherent difference between a rule-specific condition or action and a reusable one. There are, however, differences in how they are treated in a policy repository. For example, it's natural to make the access permissions for a rule-specific condition or action identical to those for the rule itself. It's also natural for a rule-specific condition or action to be removed from the policy repository at the same time the rule is. With reusable conditions and actions, on the other hand, access permissions and existence criteria must be expressible without reference to a policy rule.
The preceding paragraph does not contain an exhaustive list of the ways in which reusable and rule-specific conditions should be treated differently. Its purpose is merely to justify making a 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 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 are correct. However, there's more to the story, which only becomes clear if we examine the cardinalities separately for the two cases of a rule-specific PolicyCondition and a reusable one.
For a rule-specific PolicyCondition, the cardinality of
PolicyConditionInPolicyRule at the PolicyRule end is [1..1], rather
than [0..n] (recall that * is an abbreviation 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 the condition is not in the "re-usable" repository.
This is OK, since these are both subsets of the specified
cardinalities.
For a reusable PolicyCondition, however, the cardinality of PolicyConditionInPolicyRepository at the PolicyRepository end is [1..1], since the condition must be in the repository. And, the cardinality of 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 rule- specific condition to its PolicyRule.
Currently the only way to document constraints of this type is textually. More formal methods for documenting complex constraints are needed.
The concept of role is central to the design of the entire Policy Framework. The idea behind roles is a simple one. Rather than configuring, and then later having to update the configuration of, hundreds or thousands (or more) of resources in a network, a policy administrator assigns each resource to one or more roles, and then specifies the policies for each of these roles. The Policy Framework is then responsible for configuring each of the resources associated with a role in such a way that it behaves according to the policies specified for that role. When network behavior must be changed, the policy administrator can perform a single update to the policy for a role, and the Policy Framework will ensure that the necessary configuration updates are performed 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 be combined together. Here is a formal definition of a "role- combination":
A role-combination is a set of attributes that are used to select one or more policies for a set of entities and/or components from among a much larger set of available policies. As the examples below illustrate, the selection process for a role combination chooses policies associated with the combination itself, policies associated with each of its sub-combinations, and policies associated with each of the individual roles in the role- combination.
It is important to note that a role is more than an attribute. A role defines a particular function of an entity or component that can be used to identify particular behavior associated with that entity or component. This difference is critical, and is most easily understood by thinking of a role as a selector. When used in this manner, one role (or role-combination) selects a different set of policies than a different role (or role-combination) does.
Roles and role-combinations are especially useful in selecting which policies are applicable to a particular set of entities or components when the policy repository can store thousands or hundreds of thousands of policies. This use emphasizes the ability of the role (or role- combination) to select the small subset of policies that are applicable from 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", and "WAN". In the Policy Repository, some policy rules could be associated with the role "Ethernet"; these rules would apply to all Ethernet interfaces, regardless of whether they were on the campus side or the 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 to those on the WAN side. Finally, a third set of rules could be associated with the role-combination "Ethernet"+"WAN"; these rules would apply to the WAN-side Ethernet interfaces, but not to those on the campus side. (The roles in a 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 of policy rules applied to it: those for the "Ethernet"
role, those for the "WAN" role, and those for the role-combination
"Ethernet"+"WAN". Going 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:
In order to get all of the right policy rules for a resource like interface B, a PDP must expand the single role-combination it receives for B into this list of seven role-combinations, and then retrieve from the Policy Repository the corresponding seven sets of policy rules. Of course this example 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 of identifying conflicts between policy rules. With role-combinations, it is possible for a policy administrator to specify one set of policy rules for campus-side Ethernet interfaces, and a second set of policy rules for WAN-side Ethernet interfaces, without having to worry about conflicts between the two sets of rules. The policy administrator simply "turns off" conflict detection for these two sets of rules, by telling the policy management system that the 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 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:
+-------------------+
| Policy Repository |
+-------------------+
V
V retrieval of policy
V
+---------+
| PDP/PEP |
+---------+
v
v application of policy
v
+----------------+
| Network Entity |
+----------------+
Figure 4. Retrieval and Application of a Policy
Figure 4, which is introduced only as an example of how the Policy Framework might be implemented by a collection of network components, illustrates how roles operate within the Policy Framework. Because the distinction between them is not important to this discussion, the PDP and the PEP are combined in 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 functional characteristic or capability of a resource to which policies are applied. Examples of roles include Backbone interface, Frame Relay interface, BGP-capable router, web 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:
As indicated earlier, PolicyRoles is a property 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 to mark a policy rule as applying, for example, to a Frame Relay interface or to a backbone ATM interface. The PolicyRoles property take strings of the 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 a role combination are ANDed together to form a single selector. The multiple values of the PolicyRoles property are logically ORed, to make it possible for a policy rule to have multiple selectors.
The individual role names in a role combination must appear in
alphabetical order (according to the collating sequence for UCS-2
characters), to make the string matches work correctly. The role
names used in an environment are specified by the policy
administrator.
An instance of PolicyTimePeriodCondition has up to five properties
that represent times: TimePeriod, MonthOfYearMask, DayOfMonthMask,
DayOfWeekMask, and TimeOfDayMask. All of the time-related properties
in an instance of PolicyTimePeriodCondition represent one of two
types of times: local time at the place where a policy rule is
applied, or UTC time. The property LocalOrUtcTime indicates which
time representation applies to an instance of
PolicyTimePeriodCondition.
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 the nature of this mapping.
Suppose a policy rule is tied to the hours of operation for a Help Desk: 0800 to 2000 Monday through Friday [US] Eastern Time. In order to express these times in PolicyTimePeriodCondition, a management tool must convert them to UTC times. (They are not local times, because they refer to a single time interval worldwide, not to intervals tied to the local clocks at the locations where the
PolicyRule is being applied.) As reference [10] points out, mapping from [US] Eastern Time 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 the policy administrator's goal is 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 the end of 2001. The Policy Management Tool could either be configured with the definition of what [US] Eastern Time means, or 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 Policy Management
Tool would create however many instances of PolicyTimePeriodCondition
it needed to represent the desired intervals. Note that while there
is an increased number of PolicyTimePeriodCondition instances, there
is still just one PolicyRule, which is tied to all the
PolicyTimePeriodCondition instances via the aggregation
PolicyRuleValidityPeriod. Here are the first two of these instances:
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
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 T130000/T240000 on Mondays, and another 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 the difficult and expensive task of mapping from "human" time representations to machine-friendly ones in the Policy
Management Tool. Another approach would have been to place in 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 the one described above done once in a Policy Management Tool, rather than having it done over and over in each of the PDPs (and possibly PEPs) that need to apply a PolicyRule.
Since PCIM extends the CIM Schema, a correspondence between data types used in both CIM and PCIM is needed. The following CIM data types are used in the class definitions that follow in Sections 6 and 7:
Strings in CIM are stored as UCS-2 characters, where each character is encoded in two octets. Thus string values may need to be converted when moving between a CIM environment and 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 applied to a CIM string, a MaxLen value refers to the maximum number of characters in the string, rather than to the maximum number of octets.
In addition to the CIM data types listed above, the association classes in Section 7 use the following type:
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 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:
Mappings of the PCIM to particular data models are not required to follow this CIM technique of 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.
There are a number of differences between CIM and LDAP class specifications. The ones that are relevant to the abbreviated class specifications in this document are listed below. These items are included here to help introduce the IETF community, which is already familiar with LDAP, to CIM modeling, and by extension, to information modeling in general.
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].
The following sections contain the definitions of the PCIM classes.
The abstract class Policy collects several properties that may be included in instances of any of the Core Policy classes (or their subclasses). For convenience, the two properties that Policy inherits from ManagedElement in the CIM schema are shown here as well.
The class definition is 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)
The CN, or CommonName, property corresponds to the 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 commonly known, names that conform to the naming conventions of the country or culture with which the object is 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
This property provides a set of one or more keywords that a policy administrator may use to assist in characterizing or categorizing a policy object. Keywords are of one of two types:
This document defines the following keywords: "UNKNOWN", "CONFIGURATION", "USAGE", "SECURITY", "SERVICE", "MOTIVATIONAL", "INSTALLATION", and "EVENT". These concepts were defined earlier in Section 2.
One additional keyword is defined: "POLICY". The role of this keyword is to identify policy-related instances that would not otherwise be identifiable as being related to policy. It may be needed in some repository implementations.
Documents that define subclasses of the Policy Core Information Model classes SHOULD define additional keywords to characterize instances of these subclasses. By convention, keywords defined in conjunction with class definitions are in uppercase. Installation-defined keywords can be in any case.
The property definition is as follows:
NAME PolicyKeywords
DESCRIPTION A set of keywords for characterizing /categorizing
policy objects.
SYNTAX string
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
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
This class is a generalized aggregation container. It enables either PolicyRules or PolicyGroups to be aggregated in a single container. Loops, including the degenerate case of a PolicyGroup that contains itself, are not allowed when PolicyGroups contain other PolicyGroups.
PolicyGroups and their nesting capabilities are shown in Figure 5 below. Note that a PolicyGroup can nest other PolicyGroups, and there is no restriction on the depth of the nesting in sibling PolicyGroups.
+---------------------------------------------------+
| PolicyGroup |
| |
| +--------------------+ +-----------------+ |
| | PolicyGroup A | | PolicyGroup X | |
| | | | | |
| | +----------------+ | ooo | | |
| | | PolicyGroup A1 | | | | |
| | +----------------+ | | | |
| +--------------------+ +-----------------+ |
+---------------------------------------------------+
Figure 5. Overview of the PolicyGroup class
As a simple example, think of the highest level PolicyGroup shown 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 in Figure 5 above may define logon rules for employees on the West Coast, while another PolicyGroup might define logon rules for the Midwest (e.g., PolicyGroup X), and so forth.
Note also that the depth of each PolicyGroup does not need to be the same. Thus, the WestCoast PolicyGroup might have several additional layers of PolicyGroups defined for any of several reasons (different locales, number of subnets, etc..). The PolicyRules are therefore contained at n levels from the USEmployeeLogonPolicyGroup. Compare this to the Midwest PolicyGroup (PolicyGroup X), 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 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 class exists to aggregate PolicyRules or
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 13.1.1. Keys for an LDAP implementation will be
defined in the LDAP mapping of this information model [11].
This class represents the "If Condition then Action" semantics associated with a policy. A PolicyRule condition, in the most general sense, is represented as either an ORed set of ANDed conditions (Disjunctive Normal Form, or DNF) or an ANDed set of ORed conditions (Conjunctive Normal Form, or CNF). Individual conditions may either be negated (NOT C) or unnegated ©. The actions specified by a PolicyRule are to be performed if and only if the PolicyRule condition (whether it is represented in DNF or CNF) evaluates to TRUE.
The conditions and actions associated with a policy rule are modeled, respectively, with subclasses of the classes PolicyCondition and PolicyAction. These condition and action objects are tied to instances of PolicyRule by the PolicyConditionInPolicyRule and PolicyActionInPolicyRule aggregations.
As illustrated above in Section 3, a policy rule may also be associated with one or more policy time periods, indicating the schedule according to which the policy rule is active and inactive. In this case it is the PolicyRuleValidityPeriod aggregation that provides the linkage.
A policy rule is illustrated conceptually in Figure 6. below.
+------------------------------------------------+
| PolicyRule |
| |
| +--------------------+ +-----------------+ |
| | PolicyCondition(s) | | PolicyAction(s) | |
| +--------------------+ +-----------------+ |
| |
| +------------------------------+ |
| | PolicyTimePeriodCondition(s) | |
| +------------------------------+ |
+------------------------------------------------+
Figure 6. Overview of the PolicyRule Class
The PolicyRule class uses the property ConditionListType, to indicate whether the conditions for the rule are in DNF or CNF. The PolicyConditionInPolicyRule aggregation contains two additional properties to complete the representation of the rule's conditional expression. The first of these properties is an integer to partition the referenced 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 provide a unique representation of a set of conditions in either DNF or CNF.
Suppose we have a 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 associated with the PolicyRule.
The class definition is as follows:
NAME PolicyRule
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
The PolicyRule class 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 13.1.2. Keys for an LDAP implementation will be defined in the LDAP mapping of this information model [11].
This property indicates whether a policy rule is currently enabled, from an administrative point of view. Its purpose is to allow a policy administrator to enable or disable 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 the conditions for the policy rule, but not to 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)
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)
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
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
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
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:
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)
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
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 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.
+---------------------------------------------------------------+
| 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 13.2. Keys for an LDAP implementation will be 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 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].
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:
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
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 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.
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"
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.
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'
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'
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'
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 "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
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)
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.
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
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
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
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
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 13.3. Keys for an LDAP implementation will be 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 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].
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
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 the values is identified by the OID
stored in the property ActionEncoding.
SYNTAX octet string
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
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
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.
An association is a CIM construct representing a relationship between two (or theoretically more) objects. It is modeled as a class containing 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.
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.
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]]
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
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]]
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.
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.
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]]
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 single-valued. The [0..n] cardinality indicates that there may be 0, 1, or more than one PolicyGroups that contain any given PolicyRule.
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.
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
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.
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.
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
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
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]]
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.
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 c