Pegasus Enhancement Proposal (PEP)

PEP #: 260

PEP Type: Functional

Title: CMPI 2.0 Currency

Version: 1.1

Created: 15 May 2006

Author: Mark Hamzy / Dave Sudlik

Status: Approved

Version History:

Version Date Author Change Description
0.1 15 May 2006 Dave Sudlik
 Preliminary Draft
 1.0 11 Aug 2006
Dave Sudlik   First Draft, based on 2.0 spec going out for company review
Approved version for development.
1.1
 07 Nov 2006
 Dave Sudlik
 Final draft, minor updates based on spec changes after implementation (see bug 5817).
Final approved version.

 

Abstract:

Version 2.0 of the CMPI Standard is expected to be approved by the end of September 2006. This PEP proposes changes to OpenPegasus to support the new version of the CMPI standard.

Definition of the Problem

OpenPegasus needs to support the latest version of the CMPI standard. The areas addressed by the newest CMPI standard are:

Proposed Solution

The subsections below define the areas of enhancement in CMPI 2.0 (see section 1.4 of the spec). No incompatibilities between version 1.0 and 2.0 have been observed, but the CMPI_VERSION feature test macro allows an MI implementation (ie. provider) to define the minimal version support needed from the Management Broker (ie. CMPI run-time). Valid values are:

Any changes or additions to the CMPI functionality will also be reflected in the (non-standard) C++ "convenience" wrapper classes.

Standardized header files are now part of the specification: tog_cmpidt.h, tog_cmpift.h, tog_cmpios.h, tog_cmpipl.h. These header files include conditional compiler directives for many Operating Systems

These standardized header files originated in OpenPegasus, and still have the OpenPegasus copyright statements in them. They have been cleaned up a bit. As part of this effort, they will be merged back into OpenPegasus by comparing them against the current header files and incorporating back the OpenPegasus-specific changes (these appear to be minor and minimal). One of these differences is the placement of '#' for preprocessor directives in column 1 in the standard headers, which will eliminate many of the warning messages that are produced by gcc with the OpenPegasus CMPI headers.

Standardized CMPI Macro header (which was originally removed from the 1.0 spec via TC 1), tog_cmpimacs.h.

The situation is the same for cmpimacs.h as it is for the other CMPI header files. Differences between it and the now standardized version are minimal, mostly formatting. It will be merged into OpenPegasus in a similar manner.

Introduction of an enhanced messaging API in the CMPIBrokerEncFT interface: openMessageFile(), closeMessageFile(), getMessage2() (Sec 6.1).

These enhanced messaging APIs will be based on the OpenPegasus MessageLoader class. There are a number of changes here. Currently, CMPI getMessage() is converted into a call to MessageLoader::getMessage() which opens the ICU message file, extracts the specified message, closes the message file, and returns the formatted message (including optional message inserts). A deficiency in the existing CMPI getMessage() support is that there is no way to indicate the location of the message file to use. Today it uses the Pegasus default location, which is suitable for the CIM Server but not for providers. The interfaces for the new CMPI APIs, as they relate to Pegasus, are described here.

CMPIBrokerEncFT.openMessageFile()

CMPIStatus CMPIBrokerEncFT.openMessageFile(
        const CMPIBroker* mb,
        const char* msgFile,
        CMPIMsgFileHandle* msgFileHandle
);

The CMPIBrokerEncFT.openMessageFile() function will open a message file supported by Pegasus MessageLoader translation services and return a unique identifier to that file. This function will use the AcceptLanguage entry from the current context in determining the message file to open, and also add the ContentLanguage entry to the current context based on the actual message file that was opened. All subsequent calls to the CMPIBrokerEncFT.getMessage2() function using this msgFileHandle will be associated with this ContentLanguage.

The msgFile argument contains the implementation-specific file path to the message file. This will be used to set the msg_src_path data member of MessageLoaderParms, which tells MessageLoader where to find message resources. It can be

The msgFileHandle output argument contains a unique identifier to the open message file that can be passed to the  CMPIBrokerEncFT.getMessage2() and CMPIBrokerEncFT.closeMessageFile() functions. In Pegasus, this is just a pointer to an instance of MessageLoaderParms the is allocated on the heap. In this way, this same MessageLoaderParms instance will be used on every call to getMessage2 (which will call MessageLoader::getMessage2() under the covers, see below).

Note that for any error conditions returned by CMPIBrokerEncFT.openMessageFile(), a subsequent call to CMPIBrokerEncFT.getMessage2() using the CMPIMsgFileHandle that was returned will result in the default message being used.

CMPIBrokerEncFT.closeMessageFile()

CMPIStatus CMPIBrokerEncFT.closeMessageFile(
        const CMPIBroker* mb,
        const CMPIMsgFileHandle msgFileHandle
);

The CMPIBrokerEncFT.closeMessageFile() function will close a message file previously opened by CMPIBrokerEncFT.openMessageFile(), as specified by the msgFileHandle argument. The heap storage for the MessageLoaderParms instance will be released.

Note: If the provider returns control to the CIMOM without first closing the message file, the storage for the MessageLoaderParms instance will *not* be cleaned up. This gives a provider the option of using an open message file across multiple invocations. However, this storage will be automatically cleaned up when the provider is unloaded, if not done explicitly by the provider.

CMPIBrokerEncFT.getMessage2()

CMPIString* CMPIBrokerEncFT.getMessage2(
        const CMPIBroker* mb,
        const char* msgId,
        const CMPIMsgFileHandle msgFileHandle,
        const char* defMsg,
        CMPIStatus* rc,
        CMPICount count,
        ...
);

The CMPIBrokerEncFT.getMessage2() function will either retrieve a translated message from the open message file associated with the specified identifier, or return a default message if the message is not found.

The msgId argument is used by the Pegasus MessageLoader service to locate a message template. It will be used to set the msg_id data member of MessageLoaderParms, and represents the unique message identifier for a particular message in a message resource.

The msgFileHandle argument contains a unique identifier to the open message file that was returned by a previous call to
CMPIBrokerEncFT.openMessageFile() (ie. the MessageLoaderParms instance).

The defMsg argument is the default message used when Pegasus message translation service is not supported (eg. PEGASUS_HAS_MESSAGES is not defined) or msgId cannot be located. Up to ten message insert triggers ($0 through $9) can be interspersed in the text.

The rc output argument, if not NULL, is used to return a CMPIStatus structure containing the service return status.

The count argument defines the number of message insert pairs. Each pair has the following format:
CMPIType,value
whereby value must correspond to CMPIType. The following value types are supported: CMPI_Sint32, CMPI_uint32, CMPI_sint64, CMPI_uint64, CMPI_real64, CMPI_Boolean, CMPI_chars, and CMPI_string.

The CMPIBrokerEncFT.getMessage2() function shall return a pointer to a CMPIString structure containing either the translated or default message. The default message without insert resolution shall be returned in case an error is detected.


These APIs are intended to be used by a CMPI provider in the following way:

As can be seen here, another benefit to be gained is improved performance when more than one message is to be extracted and translated from the same message bundle. In support of this, the following new MessageLoader external interfaces will be defined. As with the existing MessageLoader interfaces, they will be qualified with PEGASUS_USE_EXPERIMENTAL_INTERFACES.

#ifdef PEGASUS_HAS_ICU
#define NO_ICU_MAGIC (UResourceBundle*)0xDEADBEEF
#else
#define NO_ICU_MAGIC (void*)0xDEADBEEF
#endif

/*
 * Opens a message resource bundle.
 * @param parms MessageLoaderParms - controls the behaviour of how a message is retrieved, this
 *     parameter should be used *ONLY* on subsequent calls to getMessage2() and closeMessageFile()
 * If this method fails for some reason, it will set parms.resbundl to NO_ICU_MAGIC, and a
 * subsequent call to getMessage2() will result in the default message being formatted.
 */
 static void openMessageFile(MessageLoaderParms &parms);
   
/*
 * Closes a message resource bundle.
 * @param parms MessageLoaderParms - identifies a previously opened resource bundle returned
 *     from openMessageFile().
 */
 static void closeMessageFile(MessageLoaderParms &parms);
   
/*
 * Retrieves a message from a message resource previously opened by openMessageFile()
 * @param parms MessageLoaderParms - controls the behaviour of how a message is retrieved, and
 *     is the same MessageLoaderParms parameter that was passed to openMessageFile().
 * @return String - the formatted message
 */
 static String getMessage2(MessageLoaderParms &parms);

Implementation note: in the interest of code compactness, the existing private method MessageLoader::loadICUMessage() will be renamed openICUMessageFile() (and called from openMessageFile()), with the calls to extractICUmessage() removed (it will be called from getMessage2()), and also the calls to ICU ures_close() removed (it will be called from closeMessageFile). Then the existing MessageLoader::getMessage() public method can be rewritten around this pseudocode:

openMessageFile(parms);
String msg = getMessage2(parms);
closeMessageFile(parms);
return msg;

CMPIInstanceFT.setPropertyWithOrigin() allows providers to set the origin on an instance property, rather than relying on the Management Broker.

This function will be implemented as a combination of CIMProperty::setValue() and CIMProperty::setClassOrigin() if the property already exists as part of the instance. If the property doesn't exist, it will be created with the CIMProperty constructor with the classOrigin CIMName specified, and then added with CIMInstance::addProperty().

One other semi-related point here is that CMPI does not currently support setProperty() or getProperty(). I would like to provide an implementation of these as such (actually, it's already done). I will do that as part of this PEP.
Note: This is similar to what happens in ProviderFacade for Pegasus C++ providers.

CMPIInstanceFT.setObjectPath() may be used to set the keys of an instance.

This is already allowed in Pegasus (done by CIMObjectRep::setPath() -- it only prevents against changing the classname).

The only change is the addition of this sentence to the description of the "op" CMPIObjectPath parameter to CMPIInstanceFT.setObjectPath():

This objectpath shall contain the namespace, classname as well as all keys for the specified instance.

Detailed explanation of use of the CMPISelectExp, CMPISelectCond, CMPISubCond, and CMPIPredOp structures in query parsing.  Addition of COD/DOC Query Normalization (Appendix A).

Nothing required here for implementation.

Introduction of the CMPIError, CMPIErrorSrcFormat structure (Sec 4.10, 4.11, 4.12, 4.13 and 6.14).

CMPIError support is optional. Availability of this support is indicated by the CMPI_MB_Supports_Extended_Error flag in CMPIBrokerFT.brokerCapabilities. CMPIError support will be implemented in Pegasus 2.6 as part of this PEP, and in conjunction with the work to be done in PEP 245 (CIM_Error).

The following data types are added:
Corresponding to the CIM_Error ErrorType property:

typedef enum _CMPIErrorType {
    Unknown = 0,
    Other = 1,
    CommunicationsError = 2,
    QualityOfServiceError = 3,
    SoftwareError = 4,
    HardwareError = 5,
    EnvironmentalError = 6,
    SecurityError = 7,
    OversubscriptionError = 8,
    UnavailableResourceError = 9,
    UnsupportedOperationError = 10,
} CMPIErrorType;

Corresponding to the CIM_Error PerceivedSeverity property:

typedef enum _CMPIErrorSeverity {
    Unknown = 0,
    Low = 2,
    Medium = 3,
    High = 4,
    Fatal = 5,
} CMPIErrorSeverity;

Corresponding to the CIM_Error ProbableCause property:

typedef enum _CMPIErrorProbableCause {
   Unknown = 0,
   Other = 1,
   Adapter_Card_Error = 2,
   Application_Subsystem_Failure = 3,
   Bandwidth_Reduced = 4,
   Connection_Establishment_Error = 5,
   Communications_Protocol_Error = 6,
   Communications_Subsystem_Failure = 7,
   Configuration/Customization_Error = 8,
   Congestion = 9,
   Corrupt_Data = 10,
   CPU_Cycles_Limit_Exceeded = 11,
   Dataset/Modem_Error = 12,
   Degraded_Signal = 13,
   DTE_DCE_Interface_Error = 14,
   Enclosure_Door_Open = 15,
   Equipment_Malfunction = 16,
   Excessive_Vibration = 17,
   File_Format_Error = 18,
   Fire_Detected = 19,
   Flood_Detected = 20,
   Framing_Error = 21,
   HVAC_Problem = 22,
   Humidity_Unacceptable = 23,
   IO_Device_Error = 24,
   Input_Device_Error = 25,
   LAN_Error = 26,
   Non_Toxic_Leak_Detected = 27,
   Local_Node_Transmission_Error = 28,
   Loss_of_Frame = 29,
   Loss_of_Signal = 30,
   Material_Supply_Exhausted = 31,
   Multiplexer_Problem = 32,
   Out_of_Memory = 33,
   Output_Device_Error = 34,
   Performance_Degraded = 35,
   Power_Problem = 36,
   Pressure_Unacceptable = 37,
   Processor_Problem = 38,
   Pump_Failure = 39,
   Queue_Size_Exceeded = 40,
   Receive_Failure = 41,
   Receiver_Failure = 42,
   Remote_Node_Transmission_Error = 43,
   Resource_at_or_Nearing_Capacity = 44,
   Response_Time_Excessive = 45,
   Retransmission_Rate_Excessive = 46,
   Software_Error = 47,
   Software_Program_Abnormally_Terminated = 48,
   Software_Program_Error = 49,
   Storage_Capacity_Problem = 50,
   Temperature_Unacceptable = 51,
   Threshold_Crossed = 52,
   Timing_Problem = 53,
   Toxic_Leak_Detected = 54,
   Transmit_Failure = 55,
   Transmitter_Failure = 56,
   Underlying_Resource_Unavailable = 57,
   Version_Mismatch = 58,
   Previous_Alert_Cleared = 59,
   Login_Attempts_Failed = 60,
   Software_Virus_Detected = 61,
   Hardware_Security_Breached = 62,
   Denial_of_Service_Detected = 63,
   Security_Credential_Mismatch = 64,
   Unauthorized_Access = 65,
   Alarm_Received = 66,
   Loss_of_Pointer = 67,
   Payload_Mismatch = 68,
   Transmission_Error = 69,
   Excessive_Error_Rate = 70,
   Trace_Problem = 71,
   Element_Unavailable = 72,
   Element_Missing = 73,
   Loss_of_Multi_Frame = 74,
   Broadcast_Channel_Failure = 75,
   Invalid_Message_Received = 76,
   Routing_Failure = 77,
   Backplane_Failure = 78,
   Identifier_Duplication = 79,
   Protection_Path_Failure = 80,
   Sync_Loss_or_Mismatch = 81,
   Terminal_Problem = 82,
   Real_Time_Clock_Failure = 83,
   Antenna_Failure = 84,
   Battery_Charging_Failure = 85,
   Disk_Failure = 86,
   Frequency_Hopping_Failure = 87,
   Loss_of_Redundancy = 88,
   Power_Supply_Failure = 89,
   Signal_Quality_Problem = 90,
   Battery_Discharging = 91,
   Battery_Failure = 92,
   Commercial_Power_Problem = 93,
   Fan_Failure = 94,
   Engine_Failure = 95,
   Sensor_Failure = 96,
   Fuse_Failure = 97,
   Generator_Failure = 98,
   Low_Battery = 99,
   Low_Fuel = 100,
   Low_Water = 101,
   Explosive_Gas = 102,
   High_Winds = 103,
   Ice_Buildup = 104,
   Smoke = 105,
   Memory_Mismatch = 106,
   Out_of_CPU_Cycles = 107,
   Software_Environment_Problem = 108,
   Software_Download_Failure = 109,
   Element_Reinitialized = 110,
   Timeout = 111,
   Logging_Problems = 112,
   Leak_Detected_113,
   Protection_Mechanism_Failure = 114,
   Protecting_Resource_Failure = 115,
   Database_Inconsistency = 116,
   Authentication_Failure = 117,
   Breach_of_Confidentiality = 118,
   Cable_Tamper = 119,
   Delayed_Information = 120,
   Duplicate_Information = 121,
   Information_Missing = 122,
   Information_Modification = 123,
   Information_Out_of_Sequence = 124,
   Key_Expired = 125,
   Non_Repudiation_Failure = 126,
   Out_of_Hours_Activity = 127,
   Out_of_Service = 128,
   Procedural_Error = 129,
   Unexpected_Information = 130,
} CMPIErrorProbableCause;

Corresponding to the CIM_Error ErrorSourceFormat property:

typedef _CMPIErrorSrcFormat {
    Unknown = 0,
    Other = 1,
    CIMObjectHandle = 2,
} CMPIErrorSrcFormat;

Also, the following functions
CMPIResultFT.returnError()

CMPIStatus CMPIResultFT.returnError(
    const CMPIResult* rslt,
    const CMPIError* er
);

The CMPIResultFT.returnError() function shall accept a CMPIError object which will be returned to the MB.

CMPIBrokerEncFT.newCMPIError()

CMPIError* CMPIBrokerEncFT.newCMPIError(
    const CMPIBroker* mb,
    const char* owner,
    const char* msgID,
    const char* msg,
    const CMPIErrorSeverity sev,
    const CMPIErrorProbableCause pc,
    const CMPIrc cimStatusCode,
    CMPIStatus* rc
);

The arguments <owner, msgID, msg, sev, pc, cimStatusCode> correspond to the CIM_Error REQUIRED properties <OwningEntity, MessageID, Message, PerceivedSeverity, ProbableCause, CIMStatusCode>. These are the minimum set of properties that must be specified when creating a CMPIError (basically, an instance of CIM_Error).

Note that the msg argument (corresponding to the CIM_Error Message property) is expected to be the error message, formatted and translated by the MI, using the values of OwningEntity, MessageID, and MessageArguments (if any), along with any other information needed for translation, like location of a message bundle and the CMPIAcceptLanguage entry from CMPIContext.

The provider is expected to supply in the CMPIError all information so that a client can do something meaningful (eg. provide other translations). This is the required properties plus any MessageAruments.

The remaining support for CMPIError is made available via the CMPIErrorFT function table. This includes get* functions for all corresponding CIM_Error properties, and set* functions for just the non-required CIM_Error properties. The required CIM_Error properties are specified on the call to newCMPIError() and may not be changed (discussion point for spec?)

typedef struct CMPIError {
    void* hdl;
    CMPIErrorFT ft;
} CMPIError;

typedef struct _CMPIErrorFT {
    CMPISint32 ftVersion;
    CMPIStatus (*release)(CMPIError*);
    CMPIError* (*clone)(const CMPIError*, CMPIStatus*);

    /* get* functions */
    CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*);
    CMPIErrorSeverity (*getPerceivedSeverity)(const CMPIError*, CMPIStatus*);
    CMPIErrorProbableCause (*getProbableCause)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getProbableCauseDescription)(const CMPIError*, CMPIStatus*);
    CMPIArray* (*getRecommendedActions)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*);
    CMPIErrorSrcFormat (*getErrorSourceFormat)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOtherErrorSourceFormat)(const CMPIError*, CMPIStatus*);
    CMPIrc (*getCIMStatusCode)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getCIMStatusCodeDescription)(const CMPIError*, CMPIStatus*);
    CMPIArray* (*getMessageArguments)(const CMPIError*, CMPIStatus*);

    /* set* functions */
    CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType);
    CMPIStatus (*setOtherErrorType)(CMPIError*, const char* );
    CMPIStatus (*setProbableCauseDescription)(CMPIError*, const char* );
    CMPIStatus (*setRecommendedActions)(CMPIError*, const CMPIArray*);
    CMPIStatus (*setErrorSource)(CMPIError*, const char*);
    CMPIStatus (*setErrorSourceFormat)(const CMPIError*, const CMPIErrorSrcFormat );
    CMPIStatus (*setOtherErrorSourceFormat)(CMPIError*, const char*);
    CMPIStatus (*setCIMStatusCodeDescription)(CMPIError*, const char*);
    CMPIStatus (*setMessageArguments)(CMPIError*, CMPIArray*);
} CMPIErrorFT;

CMPIBrokerExtFT Operating system abstraction interface is now required.

These interfaces are all already supported by Pegasus.

Introduction of the optional interface CMPIBrokerMemFT, addition of memory functions (Sec 8.10).

This set of memory functions are optional and available only when the CMPI_MB_MemoryEnhancmentSupport flag in CMPIBrokerFT.brokerCapabilities is set. CMPIBrokerMemFT is routed in CMPIBrokerFT.

These optional memory functions will not be implemented in Pegasus 2.6.

For your reading pleasure...

The functions in CMPIBrokerMemFT are memory related, and are used to guide the garbage collector, allocation and deallocation of memory. These do not replace the 'clone' and 'release' functions defined in the various CMPI data structures, those should continue to be used as previously documented. These new functions allow providers to participate more openly in the garbage collection mechanism provided by the MB, and to keep non-CMPI related memory allocated via this mechanism. A MB does not need to actually provide anything except a pass through to the underlying OS call. All MI's should use these functions for memory management.

There are three sets of memory related functions and each can help in various situations. The 'mark' and 'release' functions can be used by long-running secondary threads. The 'cmpiMalloc', 'cmpiCalloc', 'cmpiRealloc' and 'cmpiStrDup' can be used to hook-up the providers memory data storage to the MB garbage collector. The 'freeXXX' functions can be used to instruct the garbage collector that the CMPI objects are no longer needed and can be collected.

Long-running secondary threads are a common situation in indication providers. They often stay for the life-time of the MB and often create new CMPIInstance objects. Unfortunately those CMPI objects are not being garbage collected because the thread has not finished executing. The 'mark()' and 'release()' help in this fashion by setting a marker which the garbage collector can use to determine which of CMPI objects are temporary. When 'release()' is called, the garbage collector kicks in and reclaims all of the CMPI objects that have been created since the 'mark' call.

The garbage collector can also be used to support the user-defined data storage. By using the 'cmpiMalloc', 'cmpiCalloc', 'cmpiRealloc' and 'cmpiStrDup' the resulting data storage is included in the garbage collector and when it is invoked, those data storages become automatically reclaimed.

typedef struct CMPIBrokerMemFT {
    const int ftVersion;

    CMPIGcStat* (*mark)(const CMPIBroker*, CMPIStatus*);
    CMPIStatus (*release)(const CMPIBroker*, const CMPIGcStat*);
    void* (*cmpiMalloc)(const CMPIBroker*, size_t);
    void* (*cmpiCalloc)(const CMPIBroker*, size_t, size_t);
    void* (*cmpiRealloc)(const CMPIBroker*, void*, size_t);
    char* (*cmpiStrDup)(const CMPIBroker*, const char*);
    void (*cmpiFree)(const CMPIBroker*, void*);
    void (*freeInstance)(const CMPIBroker*, CMPIInstance*);
    void (*freeObjectPath)(const CMPIBroker*, CMPIObjectPath*);
    void (*freeArgs)(const CMPIBroker*, CMPIArgs*);
    void (*freeString)(const CMPIBroker*, CMPIString*);
    void (*freeArray)(const CMPIBroker*, CMPIArray*);
    void (*freeDateTime)(const CMPIBroker*, CMPIDateTime*);
    void (*freeSelectExp)(const CMPIBroker*, CMPISelectExp*);
} CMPIBrokerMemFT;

CMPICount replaces 'unsigned int' in function return values and index-based parameters (see section 4.5.6)

Affected header files, function definitions, and sample and test providers will be updated.

Many typographical errors and inconsistencies with the headers have been corrected since the 1.0 version.

In all cases that I am aware of, these errors were in the spec, with the headers being correct. However, part of the effort of this PEP will be to examine existing function definitions and compare them against the standard headers (and the spec, again, just to make sure we got them all).

One area that Pegasus is currently non-conformant is captured by bug 4985, which will be fixed as part of this effort:

CMPI 1.0 specification has the following prototype for these functions (see
section 5.1.3.4):

...
CMPIStatus (*enableIndications)(CMPIIndicationMI*,const CMPIContext*);
CMPIStatus (*disableIndications)(CMPIIndicationMI*,const CMPIContext*);

However the CMPI headers that Pegasus ships has these functions returning 'void'
(see cmpift.h lines 2612 & 2614).

Providers written to these headers are non-conformant and may crash on other
implmentations as they do not return the proper CMPIStatus object.

Incorporate changes from Technical Corrigendas

Review TC1 and TC2 changes to ensure all updates have been applied to Pegasus.

http://www.opengroup.org/tech/management/cmpi/protected/uploads/10/8300/corrigendum.txt


Rationale

It is important to stay current with the latest version of the CMPI standard. Working on the implementation while the spec is out for company review allows for (1) detailed check of the accuracy of the spec, and (2) review comments to be made on the spec before it has been approved, where errors or problems are detected. Any comments made and incorporated into the CMPI 2.0 spec as part of the company review will need to be incorporated here. Company review is expected to end around September 25th, 2006.

Schedule

Action Planned Actual Comment
PEP Submitted 08/01/2006
  08/11/2006  
PEP Reviewed 08/15/2006
  08/15/2006  version 1.0
PEP Approved 08/29/2006
  10/06/2006  version 1.0
Code Committed Pegasus 2.6
09/29/2006
  11/01/2006 Bugzillas 5734 and 5735

Discussion


Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
EMC Corporation; Symantec Corporation; The Open Group.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 

Template last modified: March 26th 2006 by Martin Kirk
Template version: 1.11