Pegasus Project Working Paper

CIM Operations Processing

AUTHORS:

Last Update 89

Revision Status

Revision | Date | Author(s) | Reason
0.1 | 16 Feb 2002 | KS | Original

Status: This is an early draft of the document to be used in discussions to complete the definition of processing.

Table of Contents

# 1 Introduction

This document defines the characteristics to be used by Pegasus for processing all CIM Operations.

To make this all as understandable as possible we have included:

The DMTF HTTP Specificaiton definitions for each operation. Note that these are the definitions current with version 1.1b of the document (currently under final review for release in March 2002).

The current client API as defined in the Pegasus module client.h

Effective Pegasus Version 2.0

This document is the basis for the definition of processing performed by Pegasus.

The following sections break down the CIM Operations defined in the DMTF document HTTP Operations and define the processing of these functions by the Pegasus system

# 2 The Strategy of Processing CIM Operations

There are several goals that we are trying to achieve in processing the CIM Operations by Pegasus. Obviously, the overriding objective is to provide valid responses that match the DMTF specifications.

However, this collection includes both read and write operations and operations that affect both the instances and the definitions of objects themselves. One of our objectives that HTTP Operations not corrupt the information integregity of Pegasus. This means that we want to assure that any changes to be made maintain the integregity of the the Pegasus information base and of the information model that is being maintained by Pegasus.

Thus, changes demanded to classes and qualifiers must result in a valid base that continues to observer the rules defined in the CIM specification. For example, (ex propogated, weak) etc. TBD

At the same time there are several tradeoffs in the design of a object management system, particularlay one like Pegasus that has multiple layers within the base itself.

First, complete protection of the base is probably prohibitively expensive. If, for example, the CIMOM itself were to validate all of the CIM defined qualifiers on requests and completely validate the responses generated, Pegasus would probably be reduced to an unacceptable level of performance.

# 3 The Pegasus Architecture

TBD

# 4 Common Elements of CIM OperationProcessing

To define the characteristics of processing for CIM Operations within Pegasus, we have broken processing into several elements including:

Request Routing – This defines the routing of requests within the CIMOM and between the CIMOM and the providers of information (entities like the repository, providers, Pegasus services, etc. are the providers of information)

Request Validation – Requests received by Pegasus must be validated for many things depending on the operation.

Request Processing – Once validated, there may be specific procsssing of requests based on the CIM Operation and the object being processed. This processing can be in the CIMOM and also in the information providers.

Response Processing – TBD

There is some common processing that must occur against ALL operations including that defined in the following sections.

## 4.1General Routing

TBD

## 4.2General Validation

- Operation against the CMOM Profile to determine if the operation is allowed – Returns CIM_ERR_NOT_SUPPORTED.
- Validation of the namespace to determine if the target namespace defined for the operation is valid.

## 4.3General Request Processing

There appear today to be a couple of categories of valid general processing as follows:

- XML process and the valid/loosely valid processing - TBD
- Conversion of the logical namespace – While it has not been approved there is a CR before the DMTF Interop group to allow the concept of a logical namespace (similar to the concept of a class name alias defined in the CIM specification but applicable to the namespace field in HTTP operations). This is applicable to all CIM operations and this conversion must be handled by Pegasu for all operations.

ACTION: Further clarify the logical namespace and our solution.

## 4.4General Response Processing

TBD

# 5 NameSpace Operations

TBD

# 6 Class Operations

## 6.1General Processing For Class Operations

### 6.1.1 Responsibility for Class Information Persistence

Today the Class repository is the only component responsible for Class information persistence. This repository is maintained by the CIMOM

### 6.1.2 Request Routing

In general, the routing of class operations is simple. There is only one provider of the information in Pegasus V2, the CIM repository. This is logical since the class repository is the only source of class information in Pegasus. All class operations are routed to this information provider. The CIM repository is also the basis for all response generation.

### 6.1.3 Request Validation

TBD

### 6.1.4 Request Processing

TBD

### 6.1.5 Response Processing

TBD

### 6.1.6 Security Issues

TBD

## 6.2Open Issues for Class Operations

There are several issues that have been discussed concerning Class operations and for which, to date, there is no clear solutions this includes:

- The possibility of a class provider – Today providers exist only for instance objects with the Class repository, in effect being the information provider for all class operations. Since the information about all of the classes is stored in the class repository, this is logical. The concept of a class provider has been discussed a number of times within the project. This would modify the class processing so that class CIM Operations might be routed to this provider rather than to the class repository. This is not a new concept – WMI uses class providers today to allow management of information in the class and instance repository. However, to date, we have not identified a clear use case for the class repository. CONCLUSION: We propose that the concept of a class repository will NOT be included in Pegasus V2.
- COMMENT: This could be considered at the same time the possibility of multiple repositories for classes is considered since they will both affect and complicate the class operation routing
- The possibility of multiple repositories for classes. A first use model for the possibility of multiple repositories simultaneously operational has been to develop but is in an early stage of development today. The implication of a requirement for multiple class repositories would be that 1) some means of routing to the proper class repository. This could, for example, be a division by namespace but the routing algorithm has not been developed at this point. CONCLUSION: We will return to this if the requirement develops but it will not be considered in the current document.

## 6.3GetClass

### 6.3.1 Function

### 6.3.2 HTTP Specification Definition

This operation is used to return a single CIM Class from the target Namespace.

GetClass

<class> GetClass (

[IN] <className> ClassName,

[IN,OPTIONAL] boolean LocalOnly = true,

[IN,OPTIONAL] boolean IncludeQualifiers = true,

[IN,OPTIONAL] boolean IncludeClassOrigin = false,

[IN,OPTIONAL,NULL] string PropertyList [] = NULL

)

The ClassName input parameter defines the name of the Class to be retrieved.

If the LocalOnly input parameter is true, this specifies that only CIM Elements (properties, methods and qualifiers) overridden within the definition of the Class are returned [1]. If false, all elements are returned. This parameter therefore effects a CIM Server-side mechanism to filter certain elements of the returned object based on whether or not they have been propagated from the parent Class (as defined by the PROPAGATED attribute).

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for that Class (including Qualifiers on the Class and on any returned Properties, Methods or

Method Parameters) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in the returned Class.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in the returned Class. If false, no CLASSORIGIN attributes are present in the returned Class.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. The returned Class MUST NOT include elements for any Properties missing from this list. Note that if LocalOnly is specified as true this acts as an additional filter on the set of Properties returned (for example, if Property A is included in the PropertyList but LocalOnly is set to true and A is not local to the requested Class, then it will not be included in the response). If the PropertyList input parameter is an empty array this signifies that no Properties are included in the response. If the PropertyList input parameter is NULL this specifies that all Properties (subject to the conditions expressed by the other parameters) are included in the response.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements which are invalid Property names for the target Class, the Server MUST ignore such entries but otherwise process the request normally.

If successful, the return value is a single CIM Class.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_NOT_FOUND (the request CIM Class does not exist in the specified namespace)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.3.3 Client API

virtual CIMClass getClass(

const String& nameSpace,

const String& className,

Boolean localOnly = true,

Boolean includeQualifiers = true,

Boolean includeClassOrigin = false,

const CIMPropertyList& propertyList = CIMPropertyList());

### 6.3.4 Routing

Same as all other class operations, the class repository.

### 6.3.5 CIM OP Request Processor Validation

General validation must include:

- Operation against the CMOM Profile – Returns CIM_ERR_NOT_SUPPORTED.

- Validation of the namespace
- Validation that the target class does exist – Returns CIM_ERR_NOT_FOUND if the class does not exist
- Validation that any properties in the property list are valid. Note that the requirement is that invalid properties are simply ignored
- Elimination of any duplicate properties in the property list to

### 6.3.6 CIM Op Request Processing

Validation (see above)

### 6.3.7 CIM Op Response Processing

See the HTTP Specification defined above. TBD.

## 6.4CreateClass

### 6.4.1 Function

CreateClass creates a single CIM Class in the target namespace.

### 6.4.2 HTTP Spec Definition

This operation is used to create a single CIM Class in the target Namespace. The Class MUST NOT already exist.

CreateClass

void CreateClass (

[IN] <class> NewClass

)

The NewClass input parameter defines the new Class. The proposed definition MUST be a correct Class definition according to the CIM specification [1].

In processing the creation of the new Class, the following rules MUST be conformed to by the CIM Server:

- Any CLASSORIGIN and PROPAGATED attributes in the NewClass MUST be ignored by the Server.
- If the new Class has no Superclass, the NewClass parameter defines a new base Class. The Server MUST ensure that all Properties and Methods of the new Class have a CLASSORIGIN attribute whose value is the name of the new Class.
- If the new Class has a Superclass, the NewClass parameter defines a new Subclass of that Superclass. The Superclass MUST exist. The Server MUST ensure that:

· Any Properties, Methods or Qualifiers in the Subclass not defined in the Superclass are created as new elements of the Subclass. In particular the Server MUST set the CLASSORIGIN attribute on the new Properties and Methods to the name of the Subclass, and ensure that all other Properties and Methods preserve their CLASSORIGIN attribute value from that defined in the Superclass.

· If a Property is defined in the Superclass and in the Subclass, the value assigned to that property in the Subclass (including NULL) becomes the default value of the property for the Subclass.

· If a Property or Method of the Superclass is not specified in the Subclass, then that Property or Method is inherited without modification by the Subclass.

· Any Qualifiers defined in the Superclass with a TOSUBCLASS attribute value of true MUST appear in the resulting Subclass. Qualifiers in the Superclass with a

· TOSUBCLASS attribute value of false MUST NOT be propagated to the Subclass.

· Any Qualifier propagated from the Superclass cannot be modified in the Subclass if the OVERRIDABLE attribute of that Qualifier was set to false in the Superclass. It is a Client error to specify such a Qualifier in the NewClass with a different definition to that in the Superclass (where definition encompasses the name, type and flavor attribute settings of the <QUALIFIER> element, and the value of the Qualifier).

If successful, the specified Class MUST have been created by the CIM Server.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_ALREADY_EXISTS (the CIM Class already exists)
- CIM_ERR_INVALID_SUPERCLASS (the putative CIM Class declares a non-existent superclass)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.4.3 Client API

virtual void createClass(

const String& nameSpace,

const CIMClass& newClass) = 0;

### 6.4.4 Routing

As with all Class operations, this is routed to the repository

### 6.4.5 CIM Operation Request Processor Validation

Validation for createclass is complex because this is the gate for all new classes input into the Pegasus repository and therefore the point of guarantee of the integretity for the repository. Both the HTTP operations and the classes created through the compiler use the same basic set of functions to create new classes.

Validation for all create Class operations includes:

- Operation against the CMOM Profile – Returns CIM_ERR_NOT_SUPPORTED.

- Namespace valid – Returns CIM_ERR_INVALID_NAMESPACE
- Valid CIM Name – Returns TBD. Fully qualified CIM Class names are required to be of the form <SchemaName>”_”<classname>. The SchemaName and “_” are required.
- SuperClass exists if defined – Returns CIM_ERR_INVALID_SUPERCLASS
- Qualifiers – All qualifiers must be valid to determine if the parameters of the qualifier are valid.
- Properties – All properties must be validated to determine if the parameters of the property are valid.
- Methods – All methods defined in the class must be validated to determine if the parameters of the method are valid
- Property and Name duplicate name validation – CHECK THIS. Should we disallow duplicate names?
- SuperClass is does not have Terminal Qualifier set.
- Cannot have both abstract qualifier and Terminal qualifier set. – This would imply that an abstract class is also the lowest possible in the hierarchy which is illogical.
- Reserved Name usage – The CIM Specification defines certain reserved words (CIM Specification, Appendix G2) that it recommends not be used as class and property names, particular property names since class names are proceeded by the SCHEMA+”_” sequence.. While to date, we have considered this a function of the compiler, in reality, it is a function of the CIMOM validation itself since class creation can come from other sources than the compiler.
- Class does not already exist – Returns CIM_ERR_ALREADY_EXISTS
- Check of propagated qualifier against class with corresponding weak qualifier if such a class exists. Returns error TBD
- Check of weak qualifier against class with corresponding propagated propagated qualifier if such a class exists. Returns error TBD.

Validation for Association Class Operations includes:

- Validate aggregation vs. aggregate qualifiers.

### 6.4.6 CIM Operation Request Processing

Valid createclass operations are installed in the repository and a response generated.

The routing for this operation is:

CIMOperationProcessor->???Queue->>CIMRepositorys

The processing is performed in the CIMRepository function and

TODO – define classorigin attribute.

Define processing in accord with the spec.

ACTION: Determine if we have any other special processing

### 6.4.7 CIM Operation Response Processing

The response processing simply returns the compete response. Since the response is small (really only confirms that the operation was performed), there are no concerns over size of returned information, etc.

## 6.5DeleteClass

### 6.5.1 Function

Delete a single class from the target namespace

### 6.5.2 HTTP Operations definition

This operation is used to delete a single CIM Class from the target Namespace.

DeleteClass

void DeleteClass (

[IN] <className> ClassName

)

The ClassName input parameter defines the name of the Class to be deleted.

If successful, the specified Class (including any subclasses and any instances) MUST have been removed by the CIM Server. The operation MUST fail if any one of these objects cannot be deleted.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_NOT_FOUND (the CIM Class to be deleted does not exist)
- CIM_ERR_CLASS_HAS_CHILDREN (the CIM Class has one or more subclasses which cannot be deleted)
- CIM_ERR_CLASS_HAS_INSTANCES (the CIM Class has one or more instances which cannot be deleted)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.5.3 Client API

virtual void deleteClass(

const String& nameSpace,

const String& className);

### 6.5.4 Routing

Same as all other Class Operations, the CIM repository

### 6.5.5 CIM OP Request Processor Validation

Namespace

Valid Namespace

Operation against the CMOM Profile – Returns CIM_ERR_NOT_SUPPORTED.

Class exists – Returns CIM_ERR_NOT_FOUND

### 6.5.6 CIM Op Request Processing

### 6.5.7 CIM Op Response Processing

### 6.5.8 Modules Involved

### 6.5.9 Open Questions

Under what conditions could subclasses or operations not be deleted? Exactly what our our rules for class deletion.

What about deleting class that are participating in associations?

## 6.6ModifyClass

### 6.6.1 Function

### 6.6.2 HTTP Operation Definition

This operation is used to modify an existing CIM Class in the target Namespace. The Class MUST already exist.

ModifyClass

void ModifyClass (

[IN] <class> ModifiedClass

)

The ModifiedClass input parameter defines the set of changes (which MUST be correct amendments to the CIM Class as defined by the CIM Specification [1]) to be made to the current class definition.

In processing the modification of the Class, the following rules MUST be conformed to by the CIM Server:

- Any CLASSORIGIN and PROPAGATED attributes in the ModifiedClass MUST be ignored by the Server.
- If the modified Class has no Superclass, the ModifiedClass parameter defines modifications to a base Class. The Server MUST ensure that:

- All Properties and Methods of the modified Class have a CLASSORIGIN attribute whose value is the name of this Class.
- Any Properties, Methods or Qualifiers in the existing Class definition which do not appear in the ModifiedClass parameter are removed from the resulting modified Class.

- If the modified Class has a Superclass, the ModifiedClass parameter defines modifications to a Subclass of that Superclass. The Superclass MUST exist, and the Client MUST NOT change the name of the Superclass in the modified Subclass. The Server MUST ensure that:

- Any Properties, Methods or Qualifiers in the Subclass not defined in the Superclass are created as elements of the Subclass. In particular the Server MUST set the
- CLASSORIGIN attribute on the new Properties and Methods to the name of the Subclass, and MUST ensure that all other Properties and Methods preserve their CLASSORIGIN attribute value from that defined in the Superclass.
- Any Property, Method or Qualifier previously defined in the Subclass but not defined in the Superclass, and which is not present in the ModifiedClass parameter, is removed from the Subclass.
- If a Property is specified in the ModifiedClass parameter, the value assigned to that property therein (including NULL) becomes the default value of the property for the Subclass.
- If a Property or Method of the Superclass is not specified in the Subclass, then that Property or Method is inherited without modification by the Subclass (so that any previous changes to such an Element in the Subclass are lost).
- If a Qualifier in the Superclass is not specified in the Subclass, and the Qualifier is defined in the Superclass with a TOSUBCLASS attribute value of true, then the Qualifier
- MUST still be present in the resulting modified Subclass (it is not possible to remove a propagated Qualifier from a Subclass).
- Any Qualifier propagated from the Superclass cannot be modified in the Subclass if the OVERRIDABLE attribute of that Qualifier was set to false in the Superclass. It is a Client error to specify such a Qualifier in the ModifiedClass with a different definition to that in the Superclass (where definition encompasses the name, type and flavor attribute settings of the <QUALIFIER> element, and the value of the Qualifier).
- Any Qualifiers defined in the Superclass with a TOSUBCLASS attribute value of false MUST NOT be propagated to the Subclass.

If successful, the specified Class MUST have been updated by the CIM Server.

The request to modify the Class MUST fail if the Server cannot update any existing Subclasses or Instances of that Class in a consistent manner.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down)

is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_NOT_FOUND (the CIM Class does not exist)
- CIM_ERR_INVALID_SUPERCLASS (the putative CIM Class declares a non-existent or incorrect superclass)
- CIM_ERR_CLASS_HAS_CHILDREN (the modification could not be performed because it was not possible to update the subclasses of the Class in a consistent fashion)
- CIM_ERR_CLASS_HAS_INSTANCES (the modification could not be performed because it was not possible to update the instances of the Class in a consistent fashion)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.6.3 Client API

virtual void modifyClass(

const String& nameSpace,

const CIMClass& modifiedClass) = 0;

### 6.6.4 Routing

Same as other class operations

### 6.6.5 CIM Operation Request Validation

Validation required:

Operation against the CMOM Profile – Returns CIM_ERR_NOT_SUPPORTED.

Namespace

Is is possible to update class children?

??? What about existing instances?

No modification to key properties.

### 6.6.6 CIM Operations Request Processing

This operation gets messy because it modifies an existing entity. It must also modify subclasses and possibly existing instances????

### 6.6.7 CIM Operation Response Processing

### 6.6.8 Modules Involved

### 6.6.9 Open Questions

Within the existing Pegasus Structure how much modification should we allow?

## 6.7EnumerateClassNames

### 6.7.1 Function

### 6.7.2 HTTP Operation Definition

This operation is used to enumerate the names of subclasses of a CIM Class in the target Namespace.

EnumerateClassNames

<className>* EnumerateClassNames (

[IN,OPTIONAL,NULL] <className> ClassName = NULL,

[IN,OPTIONAL] boolean DeepInheritance = false

)

The ClassName input parameter defines the Class that is the basis for the enumeration.

If the DeepInheritance input parameter is true, this specifies that the names of all subclasses of the specified Class should be returned (if the ClassName input parameter is absent, this implies that the names of all Classes in the target Namespace should be returned). If false, only the names of immediate child subclasses are returned (if the ClassName input parameter is NULL, this implies that the names of all base Classes in the target Namespace should be returned).

If successful, the method returns zero or more names of Classes that meet the requested criteria.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class that is the basis for this enumeration does not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.7.3 Client API

virtual Array<String> enumerateClassNames(

const String& nameSpace,

const String& className = String::EMPTY,

Boolean deepInheritance = false);

### 6.7.4 Routing

Same as other class operations.

### 6.7.5 CIM Operation Request Validation

TBD

### 6.7.6 CIM Operations Request Processing

TBD

### 6.7.7 CIM Operation Response Processing

TBD

### 6.7.8 Modules Involved

TBD

### 6.7.9 Open Questions

There are no known open questions with this operation.

## 6.8EnumerateClasses

### 6.8.1 Function

### 6.8.2 HTTP Operation Definition

This operation is used to enumerate subclasses of a CIM Class in the target Namespace.

EnumerateClasses

<class>* EnumerateClasses (

[IN,OPTIONAL,NULL] <className> ClassName=NULL,

[IN,OPTIONAL] boolean DeepInheritance = false,

[IN,OPTIONAL] boolean LocalOnly = true,

[IN,OPTIONAL] boolean IncludeQualifiers = true,

[IN,OPTIONAL] boolean IncludeClassOrigin = false

)

The ClassName input parameter defines the Class that is the basis for the enumeration.

If the DeepInheritance input parameter is true, this specifies that all subclasses of the specified Class should be returned (if the ClassName input parameter is absent, this

implies that all Classes in the target Namespace should be returned). If false, only immediate child subclasses are returned (if the ClassName input parameter is NULL, this implies that all base Classes in the target Namespace should be returned).

If the LocalOnly input parameter is true, it specifies that, for each returned Class, only elements (properties, methods and qualifiers) overridden within the definition of that Class are included [1]. If false, all elements are returned. This parameter therefore effects a CIM Server-side mechanism to filter certain elements of the returned object based on whether or not they have been propagated from the parent Class (as defined by the PROPAGATED attribute).

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for each Class (including Qualifiers on the Class and on any returned Properties, Methods or

Method Parameters) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in each returned Class.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in each returned Class. If false, no CLASSORIGIN attributes are present in each returned Class.

If successful, the method returns zero or more Classes that meet the required criteria.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class that is the basis for this enumeration does not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 6.8.3 Client API

virtual Array<CIMClass> enumerateClasses(

const String& nameSpace,

const String& className = String::EMPTY,

Boolean deepInheritance = false,

Boolean localOnly = true,

Boolean includeQualifiers = true,

Boolean includeClassOrigin = false);

### 6.8.4 Routing

The operation is processed by the CIMrepository function so that all routing is directly to the CIMRepository

### 6.8.5 CIM Operation Request Validation

Validation includes:

Operations Profile

Namespace validity

The classname that is the base for the opration is a valid classname – Returns CIM_ERR_INVALID_CLASS

### 6.8.6 CIM Operations Request Processing

The response must include the definition of the subclasses of the target class that exist in the class repository. If the className is NULL, all classes in the target namespace are enumerated.

The response includes the information for subclasses of the target class with qualifier information is includeQualifiers=true and ClassOrigin information if includeClassORigin is true. Further, if localOnly=true only elements (properties, methods and qualifiers) overridden within the definition of that Class are included.

If deepInheritance=true all classes that are subclasses of the specified class are returned.

### 6.8.7 CIM Operation Response Processing

### 6.8.8 Modules Involved

CIM Operation Processor

CIM Repository

CIM Operation Response Processor

### 6.8.9 Open Questions

Possible size of returned information. An enumeration of a complete namespace can generate a response of many megabytes. This leads us to require some means to separate the response into smaller segments for transmission.

# 7 Instance Operations

## 7.1General Processing For Instances

### 7.1.1 Responsibility for Instance Information

Unlike classes, the responsibility for instance information is divided between

- Providers
- Pegasus services
- instance repositories.

### 7.1.2 Request Routing

Whereas the request routing for classes is fixed (repository), instance requests routing is data driven, the routing is determined based on the operation, the class defined for the operation, and the existence of information providers for the target instance(s).

Generally an operation is routed to one or more of the instance information generators (providers, or Pegasus services) based on a routing definition associated with the class defined for the instance.

The routing algorithm is clearly implementation dependent and is not specified in DMTF standards.

The

Routing based on instances

Hieaarchy expansion – CIM is an object system and as such, requests for object information demand that more than simply the class being directly addressed

Routing to Instance repository – Originally the instance repository was considered the default “provider” if there was no provider specified (no provider qualifier defined a provider to process for the class). However, that was considered unacceptable for a number of reasons (See xxx). Thus

Routing is based on

### 7.1.3 Security Issues

### 7.1.4 General Request Validation

### 7.1.5 General Request Processing

### 7.1.6 General Response Processing

### 7.1.7 Modules Involved

### 7.1.8 Open Issues and future considerations

Multiple providers for a single class – One of the significant discussions to date in the implementation of providers has been the issue of multiple providers for a single class and the possible algorithims, response aggregation and response validation for this possibility.

QUESTION: Do we have a use case for multiple providers for a single class in Pegasus V 2.0?

## 7.2CreateInstance

### 7.2.1 Function

### 7.2.2 HTTP Specification Definition

This operation is used to create a single CIM Instance in the target Namespace. The Instance MUST NOT already exist.

CreateInstance

<instanceName> CreateInstance (

[IN] <instance> NewInstance

)

The NewInstance input parameter defines the new Instance. The proposed definition MUST be a correct Instance definition for the underlying CIM Class according to the CIM specification [1].

In processing the creation of the new Instance, the following rules MUST be conformed to by the CIM Server:

- Any CLASSORIGIN and PROPAGATED attributes in the NewInstance MUST be ignored by the Server.
- The Server MUST ensure that:

· Any Qualifiers in the Instance not defined in the Class are created as new elements of the Instance.

· All Properties of the Instance preserve their CLASSORIGIN attribute value from that defined in the Class.

· If a Property is specified in the ModifiedInstance parameter, the value assigned to that property in the Instance (including NULL) becomes the value of the property

· for the Instance. Note that it is a Client error to specify a Property that does not belong to the Class.

· If a Property of the Class is not specified in the Instance, then that Property is inherited without modification by the Instance.

· Servers MAY choose to ignore TOINSTANCE. Servers that do not ignore TOINSTANCE MUST interpret it as follows. Any Qualifiers defined in the Class with a TOINSTANCE attribute value of true appear in the Instance. Qualifiers in the Class with a TOINSTANCE attribute value of false MUST NOT be propagated to the instance.

· Any Qualifier propagated from the Class cannot be modified in the Instance if the OVERRIDABLE attribute of that Qualifier was set to false in the Class. It is a Client error to specify such a Qualifier in the NewInstance with a different definition to that in the Class (where definition encompasses the name, type and flavor attribute settings of the <QUALIFIER> element, and the value of the Qualifier).

If successful, the return value defines the object path of the new CIM Instance relative to the target Namespace (i.e. the Model Path as defined by [1]), created by the CIM Server. It is returned in case one or more of the new keys of the Instance are allocated dynamically during the creation process rather than specified in the request.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class of which this is to be a new Instance does not exist)
- CIM_ERR_ALREADY_EXISTS (the CIM Instance already exists)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.2.3 Client API

virtual CIMReference createInstance(

const String& nameSpace,

const CIMInstance& newInstance);

### 7.2.4 Validation

CIMOM

Valid Namespace

ClassName is valid and the class for which this instance is to be created is valid – Returns CIM_ERR_INVALID_CLASS on error

There is a valid provider for this class. This is a Pegasus validation requirement (see earlier discussion of the repository as default provider). Since Pegasus will not support the concept of the repository as default provider, an instance creation for which there is no provider must be refused.

Not an instance for an abstract class.

Determining prior existence of an instance. It is illegal to to create multiple copies of a single instance. However, it is the provider that knows if an instance already exists, not the CIMOM. Therefore, the issue for Pegasus processing is whether the CIMOM should valid the lack of prior existence of the instance by making a request to the provider or simply pass the operation to the provider and expect the provider to refuse any duplicates.

QUESTION: Should we validate duplication of instances in the CIMOM????

Verify that there is a value for all properties that have the required Qualifier.

### 7.2.5 Routing

### 7.2.6 Operation Request Processing

### 7.2.7 Operation Response Processing

## 7.3GetInstance

### 7.3.1 Function

### 7.3.2 HTTP Specification Definition

This operation is used to return a single CIM Instance from the target Namespace.

GetInstance

<instance> GetInstance (

[IN] <instanceName> InstanceName,

[IN,OPTIONAL] boolean LocalOnly = true,

[IN,OPTIONAL] boolean IncludeQualifiers = false,

[IN,OPTIONAL] boolean IncludeClassOrigin = false,

[IN,OPTIONAL,NULL] string PropertyList [] = NULL

)

The InstanceName input parameter defines the name of the Instance to be retrieved.

If the LocalOnly input parameter is true, this specifies that only elements (properties and qualifiers) overridden within the definition of the Instance are returned [1]. If false, all elements are returned. This parameter therefore effects a CIM Server-side mechanism to filter certain elements of the returned object based on whether or not they have been propagated from the parent Class (as defined by the PROPAGATED attribute).

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for that Instance (including Qualifiers on the Instance and on any returned Properties) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in the returned Instance.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in the returned Instance. If false, no CLASSORIGIN attributes are present in the returned Instance.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. The returned Instance MUST NOT include elements for any

Properties missing from this list. Note that if LocalOnly is specified as true this acts as an additional filter on the set of Properties returned (for example, if Property A is included in the PropertyList but LocalOnly is set to true and A is not local to the requested Instance, then it will not be included in the response). If the PropertyList input parameter is an empty array this signifies that no Properties are included in the response. If the PropertyList input parameter is NULL this specifies that all Properties (subject to the conditions expressed by the other parameters) are included in the response.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements which are invalid Property names for the target Instance, the Server MUST ignore such entries but otherwise process the request normally.

If successful, the return value is a single CIM Instance.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class does not exist in the specified namespace)
- CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.3.3 Client API

virtual CIMInstance getInstance(

const String& nameSpace,

const CIMReference& instanceName,

Boolean localOnly = true,

Boolean includeQualifiers = false,

Boolean includeClassOrigin = false,

const CIMPropertyList& propertyList = CIMPropertyList());

### 7.3.4 Request Validation

Validation is distributed, part in the CIMOM and part in the “provider”

CIMOM Processing

- Valid namespace
- Classname valid and class exists in the repository
- There is a valid source for this information (provider, service, etc.) – If there is none, CIM_ERR_NOT_FOUND is returned.
- Keys defined in the request are valid keys

What the CIMOM cannot validate:

That the instances do exist.

Validation required in the processor

Instance exists

Question: Do we need to validate that there is a value for all properties that have the required qualifier?

### 7.3.5 Request Routing

TBD

### 7.3.6 Request Processing

TBD

### 7.3.7 Response Processing

### 7.3.8 Open Questions

## 7.4DeleteInstance

### 7.4.1 Function

### 7.4.2 HTTP Specification Definition

This operation is used to delete a single CIM Instance from the target Namespace.

DeleteInstance

void DeleteInstance (

[IN] <instanceName> InstanceName

)

The InstanceName input parameter defines the name (model path) of the Instance to be deleted.

If successful, the specified Instance MUST have been removed by the CIM Server.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class does not exist in the specified namespace)
- CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.4.3 Client API

virtual void deleteInstance(

const String& nameSpace,

const CIMReference& instanceName);

### 7.4.4 Request Routing

### 7.4.5 Validation

### 7.4.6 Request Processing

### 7.4.7 Response Processing

## 7.5ModifyInstance

### 7.5.1 HTTP Specification Definition

This operation is used to modify an existing CIM Instance in the target Namespace. The Instance MUST already exist.

ModifyInstance

void ModifyInstance (

[IN] <namedInstance> ModifiedInstance,

[IN, OPTIONAL] boolean IncludeQualifiers = true,

[IN, OPTIONAL, NULL] string propertyList[] = NULL

)

The ModifiedInstance input parameter identifies the name of the Instance to be modified, and defines the set of changes (which MUST be correct amendments to the Instance as defined by the CIM Specification [1]) to be made to the current Instance definition.

If the IncludeQualifiers input parameter is true, this specifies that the Qualifiers are modified as specified in the ModifiedInstance.If false, Qualifiers in the ModifiedInstance are ignored and no Qualifiers are explicitly modified in the specified Instance.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. Only those properties specified in the PropertyList are modified as specified in the ModifiedInstance.Properties of the ModifiedInstance that are missing from the PropertyList are ignored.If the PropertyList input parameter is an empty array this signifies that no Properties are explicitly modified in the specified Instance. If the PropertyList input parameter is NULL this specifies that all Properties are updated in the specified Instance.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements which are invalid Property names for the target Instance, the Server MUST ignore such entries but otherwise process the request normally.

In processing the modification of the Instance, the following rules MUST be conformed to by the CIM Server:

- Any CLASSORIGIN and PROPAGATED attributes in the ModifiedInstance MUST be ignored by the Server.
- The Class MUST exist, and the Client MUST NOT change the ame of the Class in the modified Instance. The Server MUST ensure that:

- Any Qualifiers in the Instance not defined in the Class are created as new elements of the Instance if IncludeQualifiers is true.
- All Properties of the Instance preserve their CLASSORIGIN attribute value from that defined in the Class.
- Any Qualifier previously defined in the Instance but not defined in the Class, and which is not present in the ModifiedInstance parameter, is removed from the Instance if IncludeQualifiers is true.
- If a Property is specified in the ModifiedInstance and PropertyList parameters, the value assigned to that property therein (including NULL) becomes the value of the property for the Instance. Note that it is a Client error to specify a Property that does not belong to the Class.
- If a Property of the Class is not specified in the ModifiedInstance but is specified in the PropertyList, then that Property is inherited without modification by the Instance (so that any previous changes to that Property in the Instance are lost).
- Servers MAY choose to ignore TOINSTANCE. Servers that do not ignore TOINSTANCE MUST interpret it as follows. Any Qualifiers defined in the Class with a
- TOINSTANCE attribute value of true appear in the Instance (it is not possible remove a propagated Qualifier from an Instance). Qualifiers in the Class with a TOINSTANCE attribute value of false MUST NOT be propagated to the Instance
- Any Qualifier propagated from the Class cannot be modified in the Instance if the OVERRIDABLE attribute of that Qualifier was set to false in the Class. It is a Client error to specify such a Qualifier in the ModifiedInstance with a different definition to that in the Class (where definition encompasses the name, type and flavor attribute settings of the <QUALIFIER> element, and the value of the Qualifier).

If successful, the specified Instance MUST have been updated by the CIM Server.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class of which this is to be a new Instance does not exist)
- CIM_ERR_NOT_FOUND (the CIM Instance does not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.5.2 Client API

virtual void modifyInstance(

const String& nameSpace,

const CIMNamedInstance& modifiedInstance,

Boolean includeQualifiers = true,

const CIMPropertyList& propertyList = CIMPropertyList());

### 7.5.3 Validation

### 7.5.4 Routing

### 7.5.5 Request Processing

### 7.5.6 Response Processing

### 7.5.7 Open Questions

## 7.6EnumerateInstanceNames

### 7.6.1 HTTP Specification Definition

This operation is used to enumerate the names (model paths) of the instances of a CIM Class in the target Namespace.

EnumerateInstanceNames

<instanceName>* EnumerateInstanceNames (

[IN] <className> ClassName

)

The ClassName input parameter defines the Class that is the basis for the enumeration.

If successful, the method returns zero or more names of Instances (model paths) that meet the requsted criteria.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class that is the basis for this enumeration does not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.6.2 Client API

virtual Array<CIMReference> enumerateInstanceNames(

const String& nameSpace,

const String& className);

### 7.6.3 Validation

### 7.6.4 Routing

### 7.6.5 Request Processing

### 7.6.6 Response Processing

### 7.6.7 Open Questions

## 7.7EnumerateInstances

### 7.7.1 HTTP Specification Definition

This operation is used to enumerate instances of a CIM Class in the target Namespace.

EnumerateInstances

<namedInstance>* EnumerateInstances (

[IN] <className> ClassName,

[IN,OPTIONAL] boolean LocalOnly = true,

[IN,OPTIONAL] boolean DeepInheritance = true,

[IN,OPTIONAL] boolean IncludeQualifiers = false,

[IN,OPTIONAL] boolean IncludeClassOrigin = false,

[IN,OPTIONAL,NULL] string PropertyList [] = NULL

)

The ClassName input parameter defines the Class that is the basis for the enumeration.

If the LocalOnly input parameter is true, this specifies that, for each returned Instance, only elements (properties and qualifiers) overridden within the definition of that Instance are included [1]. If false, all elements are returned. This parameter therefore effects a CIM Server-side mechanism to filter certain elements of the returned object based on whether or not they have been propagated from the parent Class (as defined by the PROPAGATED attribute).

If the DeepInheritance input parameter is true, this specifies that, for each returned Instance of the Class, all properties of the Instance MUST be present (subject to constraints imposed by the other parameters), including any which were added by subclassing the specified Class. If false, each returned Instance includes only properties defined for the specified Class.

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for each Instance (including Qualifiers on the Instance and on any returned Properties) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in each returned Instance.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in each returned Instance. If false, no CLASSORIGIN attributes are present in each returned Instance.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. Each returned Instance MUST NOT include elements for any Properties missing from this list. Note that if LocalOnly is specified as true (or DeepInheritance is specified as false) this acts as an additional filter on the set of Properties returned (for example, if Property A is included in the PropertyList but LocalOnly is set to true and A is not local to a returned Instance, then it will not be included in that Instance). If the PropertyList input parameter is an empty array this signifies that no Properties are included in each returned Instance. If the PropertyList input parameter is NULL this specifies that all Properties (subject to the conditions expressed by the other parameters) are included in each returned Instance.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements which are invalid Property names for any target Instance, the Server MUST ignore such entries but otherwise process the request normally.

If successful, the method returns zero or more named Instances that meet the required criteria.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class that is the basis for this enumeration does not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 7.7.2 Client API

virtual Array<CIMNamedInstance> enumerateInstances(

const String& nameSpace,

const String& className,

Boolean deepInheritance = true,

Boolean localOnly = true,

Boolean includeQualifiers = false,

Boolean includeClassOrigin = false,

const CIMPropertyList& propertyList = CIMPropertyList());

### 7.7.3 Validation

### 7.7.4 Routing

### 7.7.5 Request Processing

### 7.7.6 Response Processing

### 7.7.7 Open Questions

# 8 Association Operations

## 8.1Associatiors

### 8.1.1 Function

### 8.1.2 HTTP Specification Definition

This operation is used to enumerate CIM Objects (Classes or Instances) that are associated to a particular source CIM Object.

Associators

<objectWithPath>* Associators (

[IN] <objectName> ObjectName,

[IN,OPTIONAL,NULL] <className> AssocClass = NULL,

[IN,OPTIONAL,NULL] <className> ResultClass = NULL,

[IN,OPTIONAL,NULL] string Role = NULL,

[IN,OPTIONAL,NULL] string ResultRole = NULL,

[IN,OPTIONAL] boolean IncludeQualifiers = false,

[IN,OPTIONAL] boolean IncludeClassOrigin = false,

[IN,OPTIONAL,NULL] string PropertyList [] = NULL

)

The ObjectName input parameter defines the source CIM Object whose associated Objects are to be returned. This may be either a Class name or Instance name (model path).

The AssocClass input parameter, if not NULL, MUST be a valid CIM Association Class name. It acts as a filter on the returned set of Objects by mandating that each returned Object MUST be associated to the source Object via an Instance of this Class or one of its subclasses.

The ResultClass input parameter, if not NULL, MUST be a valid CIM Class name. It acts as a filter on the returned set of Objects by mandating that each returned Object MUST be either an Instance of this Class (or one of its subclasses) or be this Class (or one of its subclasses).

The Role input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of Objects by mandating that each returned Object MUST be associated to the source Object via an Association in which the source Object plays the specified role (i.e. the name of the Property in the Association Class that refers to the source Object MUST match the value of this parameter).

The ResultRole input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of Objects by mandating that each returned Object MUST be associated to the source Object via an Association in which the returned Object plays the specified role (i.e. the name of the Property in the Association Class that refers to the returned Object MUST match the value of this parameter).

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for each Object (including Qualifiers on the Object and on any returned Properties) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in each returned Object.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in each returned Object. If false, no CLASSORIGIN attributes are present in each returned Object.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. Each returned Object MUST NOT include elements for any

Properties missing from this list. Note that if LocalOnly is specified as true (or DeepInheritance is specified as false) this acts as an additional filter on the set of Properties returned (for example, if Property A is included in the PropertyList but LocalOnly is set to true and A is not local to a returned Instance, then it will not be included in that Instance). If the PropertyList input parameter is an empty array this signifies that no Properties are included in each returned Object. If the PropertyList input parameter is NULL this specifies that all Properties (subject to the conditions expressed by the other parameters) are included in each returned Object.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements which are invalid Property names for any target Object, the Server MUST ignore such entries but otherwise process the request normally.

Clients SHOULD NOT explicitly specify properties in the PropertyList parameter unless they have specified a non-NULL value for the ResultClass parameter.

If successful, the method returns zero or more CIM Classes or Instances meeting the requested criteria. Since it is possible for CIM Objects from different hosts or namespaces to be associated, each returned Object includes location information.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 8.1.3 Request Routing

### 8.1.4 Request Validation

### 8.1.5 TBD

## 8.2Associator Names

The associatorNames operation enumerates the names of CIM Objects that are associated to a particular source CIM Object.

### 8.2.1 HTTP Specification Definition

This operation is used to enumerate the names of CIM Objects (Classes or Instances) that are associated to a particular source CIM Object.

AssociatorNames

<objectPath>* AssociatorNames (

[IN] <objectName> ObjectName,

[IN,OPTIONAL,NULL] <className> AssocClass = NULL,

[IN,OPTIONAL,NULL] <className> ResultClass = NULL,

[IN,OPTIONAL,NULL] string Role = NULL,

[IN,OPTIONAL,NULL] string ResultRole = NULL

)

The ObjectName input parameter defines the source CIM Object whose associated names are to be returned. This is either a Class name or Instance name (model path).

The AssocClass input parameter, if not NULL, MUST be a valid CIM Association Class name. It acts as a filter on the returned set of names by mandating that each returned name identifies an Object that MUST be associated to the source Object via an Instance of this Class or one of its subclasses.

The ResultClass input parameter, if not NULL, MUST be a valid CIM Class name. It acts as a filter on the returned set of names by mandating that each returned name identifies an Object that MUST be either an Instance of this Class (or one of its subclasses) or be this Class (or one of its subclasses).

The Role input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of names by mandating that each returned name identifies an Object that MUST be associated to the source Object via an Association in which the source Object plays the specified role (i.e. the name of the Property in the Association Class that refers to the source Object MUST match the value of this parameter).

The ResultRole input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of names by mandating that each returned name identifies an Object that MUST be associated to the source Object via an Association in which the named returned Object plays the specified role (i.e. the name of the Property in the Association Class that refers to the returned Object MUST match the value of this parameter).

If successful, the method returns zero or more full CIM Class paths or Instance paths of Objects meeting the requested criteria. Since it is possible for CIM Objects from different hosts or namespaces to be associated, each returned path is an absolute path that includes host and namespace information.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 8.2.2 Request Routing

### 8.2.3 Validation

### 8.2.4 Processing

### 8.2.5 Response Processing

## 8.3References

### 8.3.1 Function

### 8.3.2 HTTP Specification Definition

This operation is used to enumerate the association objects that refer to a particular target CIM Object (Class or Instance).

References

<objectWithPath>* References (

[IN] <objectName> ObjectName,

[IN,OPTIONAL,NULL] <className> ResultClass = NULL,

[IN,OPTIONAL,NULL] string Role = NULL,

[IN,OPTIONAL] boolean IncludeQualifiers = false,

[IN,OPTIONAL] boolean IncludeClassOrigin = false,

[IN,OPTIONAL,NULL] string PropertyList [] = NULL

)

The ObjectName input parameter defines the target CIM Object whose referring Objects are to be returned. This is either a Class name or Instance name (model path).

The ResultClass input parameter, if not NULL, MUST be a valid CIM Class name. It acts as a filter on the returned set of Objects by mandating that each returned Object MUST be an Instance of this Class (or one of its subclasses), or this Class (or one of its subclasses).

The Role input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of Objects by mandating that each returned Objects MUST refer to the target Object via a Property whose name matches the value of this parameter.

If the IncludeQualifiers input parameter is true, this specifies that all Qualifiers for each Object (including Qualifiers on the Object and on any returned Properties) MUST be included as <QUALIFIER> elements in the response. If false no <QUALIFIER> elements are present in each returned Object.

If the IncludeClassOrigin input parameter is true, this specifies that the CLASSORIGIN attribute MUST be present on all appropriate elements in each returned Object. If false, no CLASSORIGIN attributes are present in each returned Object.

If the PropertyList input parameter is not NULL, the members of the array define one or more Property names. Each returned Object MUST NOT include elements for any

Properties missing from this list. Note that if LocalOnly is specified as true (or DeepInheritance is specified as false) this acts as an additional filter on the set of

Properties returned (for example, if Property A is included in the PropertyList but LocalOnly is set to true and A is not local to a returned Instance, then it will not be included in that Instance). If the PropertyList input parameter is an empty array this signifies that no Properties are included in each returned Object. If the PropertyList input parameter is NULL this specifies that all Properties (subject to the conditions expressed by the other parameters) are included in each returned Object.

If the PropertyList contains duplicate elements, the Server MUST ignore the duplicates but otherwise process the request normally. If the PropertyList contains elements

which are invalid Property names for any target Object, the Server MUST ignore such entries but otherwise process the request normally.

Clients SHOULD NOT explicitly specify properties in the PropertyList parameter unless they have specified a non-NULL value for the ResultClass parameter.

If successful, the method returns zero or more CIM Classes or Instances meeting the requested criteria. Since it is possible for CIM Objects from different hosts or namespaces to be associated, each returned Object includes location information.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 8.3.3 Routing

### 8.3.4 Validation

### 8.3.5 Request Processing

### 8.3.6 Response Processing

## 8.4ReferenceNames

### 8.4.1 Function

### 8.4.2 HTTP Specification Definition

This operation is used to enumerate the association objects that refer to a particular target CIM Object (Class or Instance).

ReferenceNames

<objectPath>* ReferenceNames (

[IN] <objectName> ObjectName,

[IN,OPTIONAL,NULL] <className> ResultClass = NULL,

[IN,OPTIONAL,NULL] string Role = NULL

)

The ObjectName input parameter defines the target CIM Object whose referring object names are to be returned. It may be either a Class name or an Instance name (model path).

The ResultClass input parameter, if not NULL, MUST be a valid CIM Class name. It acts as a filter on the returned set of Object Names by mandating that each returned Object Name MUST identify an Instance of this Class (or one of its subclasses), or this Class (or one of its subclasses).

The Role input parameter, if not NULL, MUST be a valid Property name. It acts as a filter on the returned set of Object Names by mandating that each returned Object Name MUST identify an Object that refers to the target Instance via a Property whose name matches the value of this parameter.

If successful, the method returns the names of zero or more full CIM Class paths or Instance paths of Objects meeting the requested criteria. Since it is possible for CIM Objects from different hosts or namespaces to be associated, each returned path is an absolute path that includes host and namespace information.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 8.4.3 Routing

### 8.4.4 Validation

### 8.4.5 Request Processing

### 8.4.6 Response Processing

# 9 Property Operations

## 9.1GetProperty

### 9.1.1 Function

### 9.1.2 HTTP Specification Definition

This operation is used to retrieve a single property value from a CIM Instance in the target Namespace.

GetProperty

<propertyValue>?GetProperty (

[IN] <instanceName> InstanceName,

[IN] string PropertyName

)

The InstanceName input parameter specifies the name of the Instance (model path) from which the Property value is requested.

The PropertyName input parameter specifies the name of the Property whose value is to be returned.

If successful, the return value specifies the value of the requested Property. If the value is NULL then no element is returned.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class does not exist in the specified namespace)
- CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace)
- CIM_ERR_NO_SUCH_PROPERTY (the CIM Instance does exist, but the requested Property does not)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 9.1.3 Client API

virtual CIMValue getProperty(

const String& nameSpace,

const CIMReference& instanceName,

const String& propertyName);

### 9.1.4 Validation

### 9.1.5 Routing

### 9.1.6 Request Processing

### 9.1.7 Response Processing

### 9.1.8 Modules Involved

### 9.1.9 Open Questions

## 9.2SetProperty

### 9.2.1 Function

### 9.2.2 HTTP Specification Definition

This operation is used to set a single property value in a CIM Instance in the target Namespace.

SetProperty

void SetProperty (

[IN] <instanceName> InstanceName,

[IN] string PropertyName,

[IN,OPTIONAL,NULL] <propertyValue> NewValue = NULL

)

The InstanceName input parameter specifies the name of the Instance (model path) for which the Property value is to be updated.

The PropertyName input parameter specifies the name of the Property whose value is to be updated.

The NewValue input parameter specifies the new value for the Property (which may be NULL).

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_INVALID_CLASS (the CIM Class does not exist in the specified namespace)
- CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace)
- CIM_ERR_NO_SUCH_PROPERTY (the CIM Instance does exist, but the requested Property does not)
- CIM_ERR_TYPE_MISMATCH (the supplied value is incompatible with the type of the Property)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 9.2.3 Client API

virtual void setProperty(

const String& nameSpace,

const CIMReference& instanceName,

const String& propertyName,

const CIMValue& newValue = CIMValue());

### 9.2.4 Validation

### 9.2.5 Routing

### 9.2.6 Request Processing

### 9.2.7 Response Processing

### 9.2.8 Modules Involved

### 9.2.9 Open Questions

# 10 Method Operations

## 10.1 InvokeMethod

# 11 Qualifier Operations

## 11.1 Get Qualifier

### 11.1.1 Function

### 11.1.2 HTTP Specification Definition

This operation is used to retrieve a single Qualifier declaration from the target Namespace.

GetQualifier

<qualifierDecl> GetQualifier (

[IN] string QualifierName

)

The QualifierName input parameter identifies the Qualifier whose declaration to be retrieved.

If successful, the method returns the Qualifier declaration for the named Qualifier.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_NOT_FOUND (the requested Qualifier declaration did not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 11.1.3 Client API

virtual CIMQualifierDecl getQualifier(

const String& nameSpace,

const String& qualifierName);

### 11.1.4 Validation

### 11.1.5 Routing

### 11.1.6 Request Processing

### 11.1.7 Response Processing

### 11.1.8 Modules Involved

### 11.1.9 Open Questions

## 11.2 Set Qualifier

### 11.2.1 Function

### 11.2.2 HTTP Specification Definition

This operation is used to create or update a single Qualifier declaration in the target Namespace. If the Qualifier declaration already exists it is overwritten.

SetQualifier

void SetQualifier (

[IN] <qualifierDecl> QualifierDeclaration

)

The QualifierDeclaration input parameter defines the Qualifier Declaration to be added to the Namespace.

If successful, the Qualifier declaration MUST have been added to the target Namespace. If a Qualifier declaration with the same Qualifier name already existed, then it MUST have been replaced by the new declaration.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 11.2.3 Client API

virtual void setQualifier(

const String& nameSpace,

const CIMQualifierDecl& qualifierDeclaration);

### 11.2.4 Validation

### 11.2.5 Routing

### 11.2.6 Request Processing

### 11.2.7 Response Processing

### 11.2.8 Modules Involved

### 11.2.9 Open Questions

## 11.3 Delete Qualifier

### 11.3.1 Function

### 11.3.2 HTTP Specification Definition

This operation is used to delete a single Qualifier declaration from the target Namespace.

DeleteQualifier

void DeleteQualifier (

[IN] string QualifierName

)

The QualifierName input parameter identifies the Qualifier whose declaration to be deleted.

If successful, the specified Qualifier declaration MUST have been deleted from the Namespace.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_NOT_FOUND (the requested Qualifier declaration did not exist)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 11.3.3 Client API

virtual void deleteQualifier(

const String& nameSpace,

const String& qualifierName);

### 11.3.4 Validation

### 11.3.5 Routing

### 11.3.6 Request Processing

### 11.3.7 Response Processing

### 11.3.8 Modules Involved

### 11.3.9 Open Questions

## 11.4 EnumerateQualifiers

### 11.4.1 Function

### 11.4.2 HTTP Specification Definition

This operation is used to enumerate Qualifier declarations from the target Namespace.

EnumerateQualifiers

<qualifierDecl>* EnumerateQualifiers (

)

If successful, the method returns zero or more Qualifier declarations.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 11.4.3 Client API

virtual Array<CIMQualifierDecl> enumerateQualifiers(

const String& nameSpace);

### 11.4.4 Validation

### 11.4.5 Routing

### 11.4.6 Request Processing

### 11.4.7 Response Processing

### 11.4.8 Modules Involved

### 11.4.9 Open Questions

# 12 Query Operations

## 12.1 ExecQuery

### 12.1.1 Function

### 12.1.2 HTTP Specification Definition

This operation is used to execute a query against the target Namespace.

ExecQuery

<object>* ExecQuery (

[IN] string QueryLanguage,

[IN] string Query

)

The QueryLanguage input parameter defines the query language in which the Query parameter is expressed.

The Query input parameter defines the query to be executed.

Neither the Query language nor the format of the Query are defined by this specification. It is anticipated that Query languages will be submitted to the DMTF as separate proposals.

A mechanism whereby CIM Servers can declare which query languages they support (if any) is defined in Determining CIM Server Capabilities.

If successful, the method returns zero or more CIM Classes or Instances that correspond to the results set of the query.

If unsuccessful, one of the following status codes MUST be returned by this method, where the first applicable error in the list (starting with the first element of the list, and working down) is the error returned. Any additional method-specific interpretation of the error in is given in parentheses.

- CIM_ERR_ACCESS_DENIED
- CIM_ERR_NOT_SUPPORTED
- CIM_ERR_INVALID_NAMESPACE
- CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters)
- CIM_ERR_QUERY_LANGUAGE_NOT_SUPPORTED (the requested query language is not recognized)
- CIM_ERR_INVALID_QUERY (the query is not a valid query in the specified query language)
- CIM_ERR_FAILED (some other unspecified error occurred)

### 12.1.3 Client API

/// ATTN: should return Array<CIMObject>

virtual Array<CIMInstance> execQuery(

const String& queryLanguage,

const String& query) ;

### 12.1.4 Validation

### 12.1.5 Routing

### 12.1.6 Request Processing

### 12.1.7 Response Processing

### 12.1.8 Modules Involved

### 12.1.9 Open Questions

---END OF DOCUMENT--