version 1.23, 2005/03/12 20:16:39
|
version 1.31, 2006/02/24 19:16:28
|
|
|
//%2005//////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development | // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. | // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. | // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; | // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// EMC Corporation; VERITAS Software Corporation; The Open Group. | // EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// 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 | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
#include <Pegasus/Common/CIMMessage.h> | #include <Pegasus/Common/CIMMessage.h> |
#include <Pegasus/Common/MessageQueueService.h> | #include <Pegasus/Common/MessageQueueService.h> |
#include <Pegasus/Common/Constants.h> | #include <Pegasus/Common/Constants.h> |
#include <Pegasus/Common/ContentLanguages.h> // l10n |
|
| |
#include <Pegasus/Common/CIMClass.h> | #include <Pegasus/Common/CIMClass.h> |
#include <Pegasus/Common/CIMInstance.h> | #include <Pegasus/Common/CIMInstance.h> |
|
|
#include <Pegasus/Common/OperationContextInternal.h> | #include <Pegasus/Common/OperationContextInternal.h> |
| |
#include <Pegasus/Common/ObjectNormalizer.h> | #include <Pegasus/Common/ObjectNormalizer.h> |
#include <Pegasus/Common/ResponseHandler.h> |
|
#include <Pegasus/Common/Logger.h> |
|
#include <Pegasus/Common/XmlWriter.h> |
|
| |
|
#include <Pegasus/Common/ResponseHandler.h> |
#include <Pegasus/ProviderManager2/SimpleResponseHandler.h> | #include <Pegasus/ProviderManager2/SimpleResponseHandler.h> |
|
|
#include <Pegasus/ProviderManager2/Linkage.h> | #include <Pegasus/ProviderManager2/Linkage.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
typedef void (*PEGASUS_RESPONSE_CHUNK_CALLBACK_T)( |
|
CIMRequestMessage* request, CIMResponseMessage* response); |
|
|
class PEGASUS_PPM_LINKAGE OperationResponseHandler | class PEGASUS_PPM_LINKAGE OperationResponseHandler |
{ | { |
friend class SimpleResponseHandler; | friend class SimpleResponseHandler; |
|
|
public: | public: |
OperationResponseHandler( | OperationResponseHandler( |
CIMRequestMessage * request, | CIMRequestMessage * request, |
CIMResponseMessage * response); |
CIMResponseMessage* response, |
|
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
| |
virtual ~OperationResponseHandler(void); | virtual ~OperationResponseHandler(void); |
| |
CIMRequestMessage * getRequest(void) const |
CIMRequestMessage * getRequest(void) const; |
{ |
|
return(_request); |
|
} |
|
| |
CIMResponseMessage * getResponse(void) const |
CIMResponseMessage * getResponse(void) const; |
{ |
|
return(_response); |
|
} |
|
| |
virtual void setStatus( | virtual void setStatus( |
const Uint32 code, | const Uint32 code, |
const String & message = String::EMPTY) |
const String & message = String::EMPTY); |
{ |
|
_response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message); |
|
} |
|
| |
virtual void setStatus( | virtual void setStatus( |
const Uint32 code, | const Uint32 code, |
const ContentLanguages & langs, |
const ContentLanguageList & langs, |
const String & message = String::EMPTY) |
const String & message = String::EMPTY); |
{ |
|
_response->cimException = |
|
PEGASUS_CIM_EXCEPTION_LANG( |
|
langs, |
|
CIMStatusCode(code), |
|
message); |
|
} |
|
| |
protected: | protected: |
// the default for all derived handlers. Some handlers may not apply | // the default for all derived handlers. Some handlers may not apply |
// async behavior because their callers cannot handle partial responses. | // async behavior because their callers cannot handle partial responses. |
virtual Boolean isAsync(void) const |
virtual Boolean isAsync(void) const; |
{ |
|
return(true); |
|
} |
|
| |
// send (deliver) asynchronously | // send (deliver) asynchronously |
virtual void send(Boolean isComplete); | virtual void send(Boolean isComplete); |
| |
// transfer any objects from handler to response. this does not clear() | // transfer any objects from handler to response. this does not clear() |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
} |
|
| |
// validate whatever is necessary before the transfer | // validate whatever is necessary before the transfer |
virtual void validate(void) |
virtual void validate(void); |
{ |
|
} |
|
| |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("OperationResponseHandler")); |
|
} |
|
| |
Uint32 getResponseObjectTotal(void) const |
Uint32 getResponseObjectTotal(void) const; |
{ |
|
return(_responseObjectTotal); |
|
} |
|
| |
// there can be many objects per message (or none at all - i.e complete()) | // there can be many objects per message (or none at all - i.e complete()) |
Uint32 getResponseMessageTotal(void) const |
Uint32 getResponseMessageTotal(void) const; |
{ |
|
return(_responseMessageTotal); |
|
} |
|
| |
Uint32 getResponseObjectThreshold(void) const |
Uint32 getResponseObjectThreshold(void) const; |
{ |
|
return(_responseObjectThreshold); |
|
} |
|
| |
CIMRequestMessage * _request; | CIMRequestMessage * _request; |
CIMResponseMessage * _response; | CIMResponseMessage * _response; |
|
PEGASUS_RESPONSE_CHUNK_CALLBACK_T _responseChunkCallback; |
| |
private: | private: |
Uint32 _responseObjectTotal; | Uint32 _responseObjectTotal; |
|
|
| |
}; | }; |
| |
class GetInstanceResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler |
class PEGASUS_PPM_LINKAGE GetInstanceResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler |
{ | { |
public: | public: |
GetInstanceResponseHandler( | GetInstanceResponseHandler( |
CIMGetInstanceRequestMessage * request, | CIMGetInstanceRequestMessage * request, |
CIMGetInstanceResponseMessage * response) |
CIMGetInstanceResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
// Attempt to get the cached class definition used to validate results of this |
|
// operation. If it does not exist, then this feature is disabled for this |
|
// operation. |
|
CIMClass cimClass; |
|
|
|
try |
|
{ |
|
CachedClassDefinitionContainer container = |
|
request->operationContext.get(CachedClassDefinitionContainer::NAME); |
|
|
|
cimClass = container.getClass(); |
|
| |
} |
virtual void deliver(const CIMInstance & cimInstance); |
catch(Exception &) |
virtual void deliver(const Array<CIMInstance> & cimInstanceArray) |
{ | { |
// Do nothing. Container is missing, which implies normalization is disabled |
SimpleInstanceResponseHandler::deliver(cimInstanceArray); |
// for this operation. |
|
} | } |
| |
_normalizer = |
virtual void complete(void); |
ObjectNormalizer( |
|
cimClass, |
|
request->includeQualifiers, |
|
request->includeClassOrigin); |
|
#endif |
|
} |
|
|
|
virtual void deliver(const CIMInstance & cimInstance) |
|
{ |
|
if(cimInstance.isUninitialized()) |
|
{ |
|
MessageLoaderParms message( |
|
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
// The normalizer expects an object path embedded in instances even |
|
// though it is not required by this operation. Use the requested |
|
// object path is missing from the instance. |
|
if(cimInstance.getPath().getKeyBindings().size() == 0) |
|
{ |
|
cimInstance.setPath(request->instanceName); |
|
} |
|
|
|
SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance)); |
|
#else |
|
SimpleInstanceResponseHandler::deliver(cimInstance); |
|
#endif |
|
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("GetInstanceResponseHandler")); |
|
} |
|
|
|
virtual void transfer(void) |
|
{ |
|
if(size() > 0) |
|
{ |
|
CIMGetInstanceResponseMessage & msg = |
|
*static_cast<CIMGetInstanceResponseMessage *>(getResponse()); |
|
| |
msg.cimInstance = getObjects()[0]; |
virtual void transfer(void); |
} |
|
} |
|
| |
virtual void validate(void) |
virtual void validate(void); |
{ |
|
if(getResponseObjectTotal() == 0) |
|
{ |
|
// error? provider claims success, |
|
// but did not deliver an instance. |
|
setStatus(CIM_ERR_NOT_FOUND); |
|
} |
|
} |
|
| |
private: | private: |
ObjectNormalizer _normalizer; | ObjectNormalizer _normalizer; |
| |
}; | }; |
| |
class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler |
class PEGASUS_PPM_LINKAGE EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler |
{ | { |
public: | public: |
EnumerateInstancesResponseHandler( | EnumerateInstancesResponseHandler( |
CIMEnumerateInstancesRequestMessage * request, | CIMEnumerateInstancesRequestMessage * request, |
CIMEnumerateInstancesResponseMessage * response) |
CIMEnumerateInstancesResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
// Attempt to get the cached class definition used to validate results of this |
|
// operation. If it does not exist, then this feature is disabled for this |
|
// operation. |
|
CIMClass cimClass; |
|
| |
try |
virtual void deliver(const CIMInstance & cimInstance); |
|
virtual void deliver(const Array<CIMInstance> & cimInstanceArray) |
{ | { |
CachedClassDefinitionContainer container = |
SimpleInstanceResponseHandler::deliver(cimInstanceArray); |
request->operationContext.get(CachedClassDefinitionContainer::NAME); |
|
|
|
cimClass = container.getClass(); |
|
} |
|
catch(Exception &) |
|
{ |
|
// Do nothing. Container is missing, which implies normalization is disabled |
|
// for this operation. |
|
} |
|
|
|
_normalizer = |
|
ObjectNormalizer( |
|
cimClass, |
|
request->includeQualifiers, |
|
request->includeClassOrigin); |
|
#endif |
|
} |
|
|
|
virtual void deliver(const CIMInstance & cimInstance) |
|
{ |
|
if(cimInstance.isUninitialized()) |
|
{ |
|
MessageLoaderParms message( |
|
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance)); |
|
#else |
|
SimpleInstanceResponseHandler::deliver(cimInstance); |
|
#endif |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("EnumerateInstancesResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMEnumerateInstancesResponseMessage & msg = |
|
*static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse()); |
|
|
|
msg.cimNamedInstances = getObjects(); |
|
} |
|
| |
private: | private: |
ObjectNormalizer _normalizer; | ObjectNormalizer _normalizer; |
| |
}; | }; |
| |
class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
class PEGASUS_PPM_LINKAGE EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
{ | { |
public: | public: |
EnumerateInstanceNamesResponseHandler( | EnumerateInstanceNamesResponseHandler( |
CIMEnumerateInstanceNamesRequestMessage * request, | CIMEnumerateInstanceNamesRequestMessage * request, |
CIMEnumerateInstanceNamesResponseMessage * response) |
CIMEnumerateInstanceNamesResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
// Attempt to get the cached class definition used to validate results of this |
|
// operation. If it does not exist, then this feature is disabled for this |
|
// operation. |
|
CIMClass cimClass; |
|
|
|
try |
|
{ |
|
CachedClassDefinitionContainer container = |
|
request->operationContext.get(CachedClassDefinitionContainer::NAME); |
|
|
|
cimClass = container.getClass(); |
|
} |
|
catch(Exception &) |
|
{ |
|
// Do nothing. Container is missing, which implies normalization is disabled |
|
// for this operation. |
|
} |
|
|
|
_normalizer = |
|
ObjectNormalizer( |
|
cimClass, |
|
false, |
|
false); |
|
#endif |
|
} |
|
| |
virtual void deliver(const CIMObjectPath & cimObjectPath) |
virtual void deliver(const CIMObjectPath & cimObjectPath); |
{ |
virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray) |
if(cimObjectPath.getClassName().isNull()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectPathResponseHandler::deliver(cimObjectPathArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION |
|
SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath)); |
|
#else |
|
SimpleObjectPathResponseHandler::deliver(cimObjectPath); |
|
#endif |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("EnumerateInstanceNamesResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMEnumerateInstanceNamesResponseMessage & msg = |
|
*static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse()); |
|
|
|
msg.instanceNames = getObjects(); |
|
} |
|
| |
private: | private: |
ObjectNormalizer _normalizer; | ObjectNormalizer _normalizer; |
| |
}; | }; |
| |
class CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
class PEGASUS_PPM_LINKAGE CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
{ | { |
public: | public: |
CreateInstanceResponseHandler( | CreateInstanceResponseHandler( |
CIMCreateInstanceRequestMessage * request, | CIMCreateInstanceRequestMessage * request, |
CIMCreateInstanceResponseMessage * response) |
CIMCreateInstanceResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMObjectPath & cimObjectPath) |
virtual void deliver(const CIMObjectPath & cimObjectPath); |
{ |
virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray) |
if(cimObjectPath.getClassName().isNull()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectPathResponseHandler::deliver(cimObjectPathArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} | } |
| |
SimpleObjectPathResponseHandler::deliver(cimObjectPath); |
virtual void complete(void); |
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("CreateInstanceResponseHandler")); |
|
} |
|
|
|
#if 0 |
|
// ATTN: is it an error to not return instance name? |
|
virtual void validate(void) |
|
{ |
|
if(getResponseObjectTotal() == 0) |
|
{ |
|
setStatus(CIM_ERR_NOT_FOUND); |
|
} |
|
} |
|
#endif |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
if(size() > 0) |
|
{ |
|
CIMCreateInstanceResponseMessage & msg = |
|
*static_cast<CIMCreateInstanceResponseMessage *>(getResponse()); |
|
| |
msg.instanceName = getObjects()[0]; |
|
} |
|
} |
|
}; | }; |
| |
class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
class PEGASUS_PPM_LINKAGE ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
{ | { |
public: | public: |
ModifyInstanceResponseHandler( | ModifyInstanceResponseHandler( |
CIMModifyInstanceRequestMessage * request, | CIMModifyInstanceRequestMessage * request, |
CIMModifyInstanceResponseMessage * response) |
CIMModifyInstanceResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("ModifyInstanceResponseHandler")); |
|
} |
|
}; | }; |
| |
class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
class PEGASUS_PPM_LINKAGE DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
{ | { |
public: | public: |
DeleteInstanceResponseHandler( | DeleteInstanceResponseHandler( |
CIMDeleteInstanceRequestMessage * request, | CIMDeleteInstanceRequestMessage * request, |
CIMDeleteInstanceResponseMessage * response) |
CIMDeleteInstanceResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("DeleteInstanceResponseHandler")); |
|
} |
|
| |
}; | }; |
| |
class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler |
class PEGASUS_PPM_LINKAGE GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler |
{ | { |
public: | public: |
GetPropertyResponseHandler( | GetPropertyResponseHandler( |
CIMGetPropertyRequestMessage * request, | CIMGetPropertyRequestMessage * request, |
CIMGetPropertyResponseMessage * response) |
CIMGetPropertyResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMValue & cimValue) |
virtual void deliver(const CIMValue & cimValue); |
{ |
virtual void deliver(const Array<CIMValue> & cimValueArray) |
if(cimValue.isNull()) |
|
{ | { |
MessageLoaderParms message( |
SimpleValueResponseHandler::deliver(cimValueArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleValueResponseHandler::deliver(cimValue); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("GetPropertyResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
if(size() > 0) |
|
{ |
|
CIMGetPropertyResponseMessage & msg = |
|
*static_cast<CIMGetPropertyResponseMessage *>(getResponse()); |
|
| |
msg.value = getObjects()[0]; |
virtual void validate(void); |
} |
|
} |
|
| |
virtual void validate(void) |
|
{ |
|
// error? provider claims success, |
|
// but did not deliver an instance. |
|
if(getResponseObjectTotal() == 0) |
|
{ |
|
setStatus(CIM_ERR_NOT_FOUND); |
|
} |
|
} |
|
}; | }; |
| |
class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
class PEGASUS_PPM_LINKAGE SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler |
{ | { |
public: | public: |
SetPropertyResponseHandler( | SetPropertyResponseHandler( |
CIMSetPropertyRequestMessage * request, | CIMSetPropertyRequestMessage * request, |
CIMSetPropertyResponseMessage * response) |
CIMSetPropertyResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("SetPropertyResponseHandler")); |
|
} |
|
| |
}; | }; |
| |
class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler |
class PEGASUS_PPM_LINKAGE ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler |
{ | { |
public: | public: |
ExecQueryResponseHandler( | ExecQueryResponseHandler( |
CIMExecQueryRequestMessage * request, | CIMExecQueryRequestMessage * request, |
CIMExecQueryResponseMessage * response) |
CIMExecQueryResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMInstance & cimInstance) |
virtual void deliver(const CIMInstance & cimInstance); |
{ |
virtual void deliver(const Array<CIMInstance> & cimInstanceArray) |
if(cimInstance.isUninitialized()) |
|
{ | { |
MessageLoaderParms message( |
SimpleInstance2ObjectResponseHandler::deliver(cimInstanceArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleInstance2ObjectResponseHandler::deliver(cimInstance); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("ExecQueryResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMExecQueryResponseMessage & msg = |
|
*static_cast<CIMExecQueryResponseMessage *>(getResponse()); |
|
| |
msg.cimObjects = getObjects(); |
virtual Boolean isAsync(void) const; |
} |
|
| |
virtual Boolean isAsync(void) const |
|
{ |
|
return(false); |
|
} |
|
}; | }; |
| |
class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler |
class PEGASUS_PPM_LINKAGE AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler |
{ | { |
public: | public: |
AssociatorsResponseHandler( | AssociatorsResponseHandler( |
CIMAssociatorsRequestMessage * request, | CIMAssociatorsRequestMessage * request, |
CIMAssociatorsResponseMessage * response) |
CIMAssociatorsResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMObject & cimObject) |
virtual void deliver(const CIMObject & cimObject); |
{ |
virtual void deliver(const Array<CIMObject> & cimObjectArray) |
if(cimObject.isUninitialized()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectResponseHandler::deliver(cimObjectArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleObjectResponseHandler::deliver(cimObject); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("AssociatorsResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMAssociatorsResponseMessage & msg = |
|
*static_cast<CIMAssociatorsResponseMessage *>(getResponse()); |
|
| |
msg.cimObjects = getObjects(); |
|
} |
|
}; | }; |
| |
class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
class PEGASUS_PPM_LINKAGE AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
{ | { |
public: | public: |
AssociatorNamesResponseHandler( | AssociatorNamesResponseHandler( |
CIMAssociatorNamesRequestMessage * request, | CIMAssociatorNamesRequestMessage * request, |
CIMAssociatorNamesResponseMessage * response) |
CIMAssociatorNamesResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMObjectPath & cimObjectPath) |
virtual void deliver(const CIMObjectPath & cimObjectPath); |
{ |
virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray) |
if(cimObjectPath.getClassName().isNull()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectPathResponseHandler::deliver(cimObjectPathArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleObjectPathResponseHandler::deliver(cimObjectPath); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("AssociatorNamesResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMAssociatorNamesResponseMessage & msg = |
|
*static_cast<CIMAssociatorNamesResponseMessage *>(getResponse()); |
|
| |
msg.objectNames = getObjects(); |
|
} |
|
}; | }; |
| |
class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler |
class PEGASUS_PPM_LINKAGE ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler |
{ | { |
public: | public: |
ReferencesResponseHandler( | ReferencesResponseHandler( |
CIMReferencesRequestMessage * request, | CIMReferencesRequestMessage * request, |
CIMReferencesResponseMessage * response) |
CIMReferencesResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMObject & cimObject) |
virtual void deliver(const CIMObject & cimObject); |
{ |
virtual void deliver(const Array<CIMObject> & cimObjectArray) |
if(cimObject.isUninitialized()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectResponseHandler::deliver(cimObjectArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleObjectResponseHandler::deliver(cimObject); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("ReferencesResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMReferencesResponseMessage & msg = |
|
*static_cast<CIMReferencesResponseMessage *>(getResponse()); |
|
| |
msg.cimObjects = getObjects(); |
|
} |
|
}; | }; |
| |
class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
class PEGASUS_PPM_LINKAGE ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler |
{ | { |
public: | public: |
ReferenceNamesResponseHandler( | ReferenceNamesResponseHandler( |
CIMReferenceNamesRequestMessage * request, | CIMReferenceNamesRequestMessage * request, |
CIMReferenceNamesResponseMessage * response) |
CIMReferenceNamesResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
| |
virtual void deliver(const CIMObjectPath & cimObjectPath) |
virtual void deliver(const CIMObjectPath & cimObjectPath); |
{ |
virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray) |
if(cimObjectPath.getClassName().isNull()) |
|
{ | { |
MessageLoaderParms message( |
SimpleObjectPathResponseHandler::deliver(cimObjectPathArray); |
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
SimpleObjectPathResponseHandler::deliver(cimObjectPath); |
|
} | } |
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("ReferenceNamesResponseHandler")); |
|
} |
|
| |
virtual void transfer(void) |
virtual void transfer(void); |
{ |
|
CIMReferenceNamesResponseMessage & msg = |
|
*static_cast<CIMReferenceNamesResponseMessage *>(getResponse()); |
|
| |
msg.objectNames = getObjects(); |
|
} |
|
}; | }; |
| |
class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler |
class PEGASUS_PPM_LINKAGE InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler |
{ | { |
public: | public: |
InvokeMethodResponseHandler( | InvokeMethodResponseHandler( |
CIMInvokeMethodRequestMessage * request, | CIMInvokeMethodRequestMessage * request, |
CIMInvokeMethodResponseMessage * response) |
CIMInvokeMethodResponseMessage* response, |
: OperationResponseHandler(request, response) |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
{ |
|
} |
|
|
|
virtual void deliverParamValue(const CIMParamValue & cimParamValue) |
|
{ |
|
if(cimParamValue.isUninitialized()) |
|
{ |
|
MessageLoaderParms message( |
|
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
| |
SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue); |
virtual void deliverParamValue(const CIMParamValue & cimParamValue); |
} |
virtual void deliverParamValue( |
|
const Array<CIMParamValue> & cimParamValueArray) |
virtual void deliver(const CIMValue & cimValue) |
|
{ | { |
if(cimValue.isNull()) |
SimpleMethodResultResponseHandler::deliverParamValue( |
{ |
cimParamValueArray); |
MessageLoaderParms message( |
|
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} | } |
| |
SimpleMethodResultResponseHandler::deliver(cimValue); |
virtual void deliver(const CIMValue & cimValue); |
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("InvokeMethodResponseHandler")); |
|
} |
|
|
|
virtual void transfer(void) |
|
{ |
|
CIMInvokeMethodResponseMessage & msg = |
|
*static_cast<CIMInvokeMethodResponseMessage *>(getResponse()); |
|
| |
msg.outParameters = getParamValues(); |
virtual void transfer(void); |
| |
// ATTN-RK-20020903: Is it legal for the return value to be null? |
|
// if not, then the check must be done here since deliver() works off the |
|
// virtual size, which refers to out parameters! |
|
msg.retValue = getReturnValue(); |
|
} |
|
}; | }; |
| |
typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*); |
typedef void (*PEGASUS_INDICATION_CALLBACK_T)( |
|
CIMProcessIndicationRequestMessage*); |
| |
class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler |
class PEGASUS_PPM_LINKAGE EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler |
{ | { |
public: | public: |
EnableIndicationsResponseHandler( | EnableIndicationsResponseHandler( |
CIMRequestMessage * request, | CIMRequestMessage * request, |
CIMResponseMessage * response, | CIMResponseMessage * response, |
CIMInstance & provider, | CIMInstance & provider, |
PEGASUS_INDICATION_CALLBACK indicationCallback) |
PEGASUS_INDICATION_CALLBACK_T indicationCallback, |
: OperationResponseHandler(request, response), |
PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback); |
_indicationCallback(indicationCallback) |
|
{ |
|
_provider = provider; |
|
} |
|
|
|
virtual void deliver(const CIMIndication & cimIndication) |
|
{ |
|
OperationContext context; |
|
|
|
Array<CIMObjectPath> subscriptionInstanceNames; |
|
|
|
context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames)); |
|
|
|
deliver(context, cimIndication); |
|
} |
|
|
|
virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication) |
|
{ |
|
if(cimIndication.isUninitialized()) |
|
{ |
|
MessageLoaderParms message( |
|
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION", |
|
"The object is not initialized."); |
|
|
|
throw CIMException(CIM_ERR_FAILED, message); |
|
} |
|
|
|
// ATTN: temporarily convert indication to instance |
|
CIMInstance cimInstance(cimIndication); |
|
| |
// Get list of subscription instance names from context |
virtual void deliver(const CIMIndication & cimIndication); |
Array<CIMObjectPath> subscriptionInstanceNames; |
|
| |
try |
virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication); |
{ |
|
SubscriptionInstanceNamesContainer container = |
|
context.get(SubscriptionInstanceNamesContainer::NAME); |
|
|
|
subscriptionInstanceNames = container.getInstanceNames(); |
|
} |
|
catch(Exception &) |
|
{ |
|
subscriptionInstanceNames.clear(); |
|
} |
|
|
|
// l10n |
|
ContentLanguages contentLangs; |
|
|
|
try |
|
{ |
|
// Get the Content-Language for this indication. The provider |
|
// does not have to add specify a language for the indication. |
|
ContentLanguageListContainer langContainer = |
|
context.get(ContentLanguageListContainer::NAME); |
|
|
|
contentLangs = langContainer.getLanguages(); |
|
} |
|
catch(Exception &) |
|
{ |
|
// The provider did not explicitly set a Content-Language for |
|
// the indication. Fall back to the lang set in this object. |
|
contentLangs = getLanguages(); |
|
} |
|
// l10n -end |
|
|
|
// create message |
|
// l10n |
|
CIMProcessIndicationRequestMessage * request = |
|
new CIMProcessIndicationRequestMessage( |
|
XmlWriter::getNextMessageId(), |
|
cimInstance.getPath().getNameSpace(), |
|
cimInstance, |
|
subscriptionInstanceNames, |
|
_provider, |
|
QueueIdStack()); // Must be filled in by the callback function |
|
|
|
request->operationContext = context; |
|
|
|
try |
|
{ |
|
request->operationContext.set(ContentLanguageListContainer(contentLangs)); |
|
} |
|
catch(Exception &) |
|
{ |
|
request->operationContext.insert(ContentLanguageListContainer(contentLangs)); |
|
} |
|
|
|
_indicationCallback(request); |
|
} |
|
|
|
virtual void deliver(const Array<CIMIndication> & cimIndications) |
|
{ |
|
OperationContext context; |
|
| |
deliver(context, cimIndications); |
virtual void deliver(const Array<CIMIndication> & cimIndications); |
} |
|
| |
virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications) |
virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications); |
{ |
|
for(Uint32 i = 0, n = cimIndications.size(); i < n; i++) |
|
{ |
|
deliver(context, cimIndications[i]); |
|
} |
|
} |
|
| |
protected: | protected: |
virtual String getClass(void) const |
virtual String getClass(void) const; |
{ |
|
return(String("EnableIndicationsResponseHandler")); |
|
} |
|
| |
virtual Boolean isAsync(void) const |
virtual Boolean isAsync(void) const; |
{ |
|
return(false); |
|
} |
|
| |
private: | private: |
PEGASUS_INDICATION_CALLBACK _indicationCallback; |
PEGASUS_INDICATION_CALLBACK_T _indicationCallback; |
| |
}; | }; |
| |