version 1.5.2.13, 2013/10/13 21:31:59
|
version 1.15, 2014/08/27 23:10:08
|
|
|
#include <Pegasus/Common/CIMInternalXmlEncoder.h> | #include <Pegasus/Common/CIMInternalXmlEncoder.h> |
#include <Pegasus/Common/SCMOInternalXmlEncoder.h> | #include <Pegasus/Common/SCMOInternalXmlEncoder.h> |
| |
// KS_TODO_DELETE |
|
#include <Pegasus/Common/Print.h> |
|
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
| |
|
|
// Defines debug code in CIMResponseData. This under this | // Defines debug code in CIMResponseData. This under this |
// special compile flag so that it can be compiled independent of | // special compile flag so that it can be compiled independent of |
// PEGASUS_DEBUG flags. | // PEGASUS_DEBUG flags. |
#define CIMRESPONSEDATA_DEBUG |
// #define CIMRESPONSEDATA_DEBUG |
| |
#define LOCAL_MIN(a, b) ((a < b) ? a : b) | #define LOCAL_MIN(a, b) ((a < b) ? a : b) |
// C++ objects interface handling |
|
| |
// KS_TODO Remove this completely when finished testing. |
/* |
bool CIMResponseData::sizeValid() |
Append an InstanceElement to the Buffer. This function accounts |
|
for the existence of a propertyList. |
|
*/ |
|
void CIMResponseData::_appendInstanceElement( |
|
Buffer& out, |
|
SCMOInstance _scmoInstance) |
{ | { |
PEGASUS_DEBUG_ASSERT(valid()); |
if(_propertyList.isNull()) |
#ifdef CIMRESPONSEDATA_DEBUG |
|
if (_size > 1000000) |
|
{ | { |
cout << "CIMResponseData::PSVALID _size too big " << _size << endl; |
Array<Uint32> emptyNodes; |
PEG_TRACE((TRC_XML, Tracer::LEVEL4, |
SCMOXmlWriter::appendInstanceElement( |
"CIMResponseData::PSVALID _size too big %u",_size )); |
out, |
return false; |
_scmoInstance, |
|
false, |
|
emptyNodes); |
} | } |
#endif |
else |
PEG_TRACE((TRC_XML, Tracer::LEVEL4, |
{ |
"CIMResponseData Size _size=%u", _size)); |
Array<propertyFilterNodesArray_t> propFilterNodesArrays; |
return true; |
// This searches for an already created array of nodes, |
|
//if not found, creates it inside propFilterNodesArrays |
|
const Array<Uint32> & nodes= |
|
SCMOXmlWriter::getFilteredNodesArray( |
|
propFilterNodesArrays, |
|
_scmoInstance, |
|
_propertyList); |
|
SCMOXmlWriter::appendInstanceElement( |
|
out, |
|
_scmoInstance, |
|
true, |
|
nodes); |
} | } |
|
} |
|
|
// Instance Names handling | // Instance Names handling |
Array<CIMObjectPath>& CIMResponseData::getInstanceNames() | Array<CIMObjectPath>& CIMResponseData::getInstanceNames() |
{ | { |
PSVALID; |
|
PEGASUS_DEBUG_ASSERT( | PEGASUS_DEBUG_ASSERT( |
(_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS)); | (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS)); |
_resolveToCIM(); | _resolveToCIM(); |
|
|
{ | { |
| |
PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setSCMO"); | PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setSCMO"); |
//// AutoMutex autoMut(testLock); |
|
PSVALID; |
|
_scmoInstances=x; | _scmoInstances=x; |
_encoding |= RESP_ENC_SCMO; | _encoding |= RESP_ENC_SCMO; |
_size += x.size(); | _size += x.size(); |
|
|
bool CIMResponseData::setBinary(CIMBuffer& in) | bool CIMResponseData::setBinary(CIMBuffer& in) |
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary"); | PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary"); |
//// AutoMutex autoMut(testLock); |
|
| |
// Append all serial data from the CIMBuffer to the local data store. | // Append all serial data from the CIMBuffer to the local data store. |
// Returns error if input not a serialized Uint8A | // Returns error if input not a serialized Uint8A |
|
|
| |
bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in) | bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in) |
{ | { |
//// AutoMutex autoMut(testLock); |
|
PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData"); | PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData"); |
| |
// Append any data that has not been deserialized already from | // Append any data that has not been deserialized already from |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::moveObjects"); | PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::moveObjects"); |
| |
//// AutoMutex autoMut(testLock); |
|
|
|
PEG_TRACE((TRC_XML, Tracer::LEVEL3, | PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
"CIMResponseData::move(%u)", count)); | "CIMResponseData::move(%u)", count)); |
| |
|
|
} | } |
break; | break; |
| |
// KS-TODO The above could probably be folded into the following. |
// KS-FUTURE The above could probably be folded into the following. |
// Need something like an assert if there is ever more than | // Need something like an assert if there is ever more than |
// one instance in _instanceData for type RESP_INSTANCE | // one instance in _instanceData for type RESP_INSTANCE |
case RESP_INSTANCES: | case RESP_INSTANCES: |
|
|
| |
_size += rtnSize; | _size += rtnSize; |
| |
// insure that _size never goes negative. This is probably a |
// Insure that _size never goes negative. This is a |
// diagnostics KS_TODO remove before release |
// diagnostic. KS_TODO remove before release |
if (from._size >= rtnSize) | if (from._size >= rtnSize) |
{ | { |
| |
|
|
else | else |
{ | { |
from._size = 0; | from._size = 0; |
//// KS_TODO Diagnostic since this should never occur |
|
PEG_TRACE((TRC_XML, Tracer::LEVEL1, |
|
"Size in from set to zero from= %u rtnSize= %u", |
|
from._size, rtnSize)); |
|
} | } |
| |
//// KS_TODO diagnostic that we should be able to remove |
//// KS_TODO diagnostic that we should be able to remove before |
|
//// release |
if (rtnSize != _size) | if (rtnSize != _size) |
{ | { |
PEG_TRACE((TRC_XML, Tracer::LEVEL1, | PEG_TRACE((TRC_XML, Tracer::LEVEL1, |
|
|
// Sets the _size variable based on the internal size counts. | // Sets the _size variable based on the internal size counts. |
void CIMResponseData::setSize() | void CIMResponseData::setSize() |
{ | { |
PEGASUS_DEBUG_ASSERT(valid()); //KS_TEMP KS_TODO |
PEGASUS_DEBUG_ASSERT(valid()); |
| |
Uint32 rtnSize = 0; | Uint32 rtnSize = 0; |
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
|
|
} | } |
_size = rtnSize; | _size = rtnSize; |
} | } |
|
|
// Return the number of CIM objects in the CIM Response data object |
|
// | // |
#define TEMPLOG PEG_TRACE((TRC_XML, Tracer::LEVEL4, \ |
// Return the number of CIM objects in the CIM Response data object by |
"rtnSize %u size %u line %u", rtnSize, _size, __LINE__)) |
// aggregating sizes of each of the encodings |
//#define TEMPLOG cout << "rtnSize " << rtnSize << " _size " << _size |
// |
//<< " line " << __LINE__ << endl |
|
|
|
Uint32 CIMResponseData::size() | Uint32 CIMResponseData::size() |
{ | { |
AutoMutex autoMut(testLock); |
|
PEG_METHOD_ENTER(TRC_XML,"CIMResponseData::size()"); |
|
PSVALID; |
|
// If debug mode, add up all the individual size components to | // If debug mode, add up all the individual size components to |
// determine overall size of this object. Then compare this with | // determine overall size of this object. Then compare this with |
// the _size variable. this is a good check on the completeness of the |
// the _size variable. This is a check on the completeness of the |
// size computations. We should be able to remove this at some point | // size computations. We should be able to remove this at some point |
// but there are many sources of size info and we need to be sure we | // but there are many sources of size info and we need to be sure we |
// have covered them all. | // have covered them all. |
#ifdef PEGASUS_DEBUG |
#ifdef CIMRESPONSEDATA_DEBUG |
PEGASUS_DEBUG_ASSERT(valid()); //KS_TEMP KS_TODO |
PEGASUS_DEBUG_ASSERT(valid()); |
| |
Uint32 rtnSize = 0; | Uint32 rtnSize = 0; |
TEMPLOG; |
|
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
{ | { |
TEMPLOG; |
|
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
|
|
rtnSize += _instanceData.size(); | rtnSize += _instanceData.size(); |
break; | break; |
} | } |
PSVALID; |
|
TEMPLOG; |
|
} | } |
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) | if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
{ | { |
TEMPLOG; |
|
// KS_PULL_TODO | // KS_PULL_TODO |
// Cannot resolve this one without actually processing | // Cannot resolve this one without actually processing |
// the data since it is a stream. | // the data since it is a stream. |
rtnSize += 0; | rtnSize += 0; |
// KS_TODO flag on this one |
|
//// PEGASUS_ASSERT(false); |
|
TEMPLOG; |
|
} | } |
| |
if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) | if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO)) |
{ | { |
PSVALID; |
|
TEMPLOG; |
|
rtnSize += _scmoInstances.size(); | rtnSize += _scmoInstances.size(); |
TEMPLOG; |
|
} | } |
| |
if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) | if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)) |
{ | { |
PSVALID; |
|
TEMPLOG; |
|
switch (_dataType) | switch (_dataType) |
{ | { |
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
|
|
rtnSize += _objects.size(); | rtnSize += _objects.size(); |
break; | break; |
} | } |
PSVALID; |
|
TEMPLOG; |
|
} | } |
// Test of actual count against _size variable. KS_TODO diagnostic | // Test of actual count against _size variable. KS_TODO diagnostic |
if (rtnSize != _size) |
Uint32 lsize = _size; |
|
if (rtnSize != lsize) |
{ | { |
TEMPLOG; |
|
PSVALID; |
|
PEG_TRACE((TRC_XML, Tracer::LEVEL1, | PEG_TRACE((TRC_XML, Tracer::LEVEL1, |
"CIMResponseData::size ERROR. debug size mismatch." | "CIMResponseData::size ERROR. debug size mismatch." |
"Computed = %u. variable = %u",rtnSize, _size )); |
"Computed = %u. variable = %u inc binary %s",rtnSize, _size, |
// KS_TEMP |
boolToString(RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
cout << "Size err Computed(rtnsize)=" << rtnSize << " _size=" << _size |
)); |
<< " diff=" << (rtnSize - _size) << endl; |
|
TEMPLOG; |
|
} | } |
PEG_TRACE((TRC_XML, Tracer::LEVEL1, "ReturnSize=%u", _size )); |
|
#endif | #endif |
PEG_METHOD_EXIT(); |
|
return _size; | return _size; |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, | PEG_METHOD_ENTER(TRC_DISPATCHER, |
"CIMResponseData::appendResponseData"); | "CIMResponseData::appendResponseData"); |
//// AutoMutex autoMut(testLock); |
|
|
PEGASUS_DEBUG_ASSERT(valid()); |
|
|
// Confirm that the CIMResponseData type matches the type | // Confirm that the CIMResponseData type matches the type |
// of the data being appended | // of the data being appended |
|
// A CIMResponseData must represent a single data content type. |
|
// ex. Cannot mix objects and instances. |
| |
PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP |
|
PEGASUS_DEBUG_ASSERT(_dataType == x._dataType); | PEGASUS_DEBUG_ASSERT(_dataType == x._dataType); |
_encoding |= x._encoding; | _encoding |= x._encoding; |
| |
// add all binary data | // add all binary data |
_binaryData.appendArray(x._binaryData); | _binaryData.appendArray(x._binaryData); |
// KS_TBD TODO PULL Add the counter incrementer for binary |
|
| |
// add all the C++ stuff | // add all the C++ stuff |
_instanceNames.appendArray(x._instanceNames); | _instanceNames.appendArray(x._instanceNames); |
|
|
_scmoInstances.appendArray(x._scmoInstances); | _scmoInstances.appendArray(x._scmoInstances); |
_size += x._scmoInstances.size(); | _size += x._scmoInstances.size(); |
| |
// add Xml encodings |
|
// KS_TODO these are temporary. delete before release |
|
PEGASUS_ASSERT(x._referencesData.size() == x._instanceData.size()); |
|
PEGASUS_ASSERT(x._instanceData.size() == x._hostsData.size()); |
|
PEGASUS_ASSERT(x._instanceData.size() == x._nameSpacesData.size()); |
|
|
|
_referencesData.appendArray(x._referencesData); | _referencesData.appendArray(x._referencesData); |
_instanceData.appendArray(x._instanceData); | _instanceData.appendArray(x._instanceData); |
_hostsData.appendArray(x._hostsData); | _hostsData.appendArray(x._hostsData); |
_nameSpacesData.appendArray(x._nameSpacesData); | _nameSpacesData.appendArray(x._nameSpacesData); |
_size += x._instanceData.size(); | _size += x._instanceData.size(); |
| |
|
|
|
|
// transfer property list | // transfer property list |
_propertyList = x._propertyList; | _propertyList = x._propertyList; |
| |
|
|
PEG_METHOD_ENTER(TRC_DISPATCHER, | PEG_METHOD_ENTER(TRC_DISPATCHER, |
"CIMResponseData::encodeBinaryResponse"); | "CIMResponseData::encodeBinaryResponse"); |
| |
PSVALID; |
|
|
|
// Need to do a complete job here by transferring all contained data | // Need to do a complete job here by transferring all contained data |
// into binary format and handing it out in the CIMBuffer | // into binary format and handing it out in the CIMBuffer |
// KS_TODO |
// FUTURE. For now we do not handle binary in the pull |
|
// operations and therefore convert back to another encoding. |
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) | if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
{ | { |
PEGASUS_ASSERT(false); // KS_TEMP |
|
|
|
// Binary does NOT need a marker as it consists of C++ and SCMO | // Binary does NOT need a marker as it consists of C++ and SCMO |
const Array<Uint8>& data = _binaryData; | const Array<Uint8>& data = _binaryData; |
out.putBytes(data.getData(), data.size()); | out.putBytes(data.getData(), data.size()); |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
} | } |
|
|
if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) | if (RESP_ENC_XML == (_encoding & RESP_ENC_XML)) |
{ | { |
// This actually should not happen following general code logic | // This actually should not happen following general code logic |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
PEG_METHOD_ENTER(TRC_DISPATCHER, | PEG_METHOD_ENTER(TRC_DISPATCHER, |
"CIMResponseData::completeHostNameAndNamespace"); | "CIMResponseData::completeHostNameAndNamespace"); |
| |
PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP |
PEGASUS_DEBUG_ASSERT(valid()); |
|
|
Uint32 count = 0; //// KS_TODO this counter is just diagnostic |
|
|
|
PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4, // KS_TODO TEMP |
|
"completeHostNameAndNamespace Setting hostName, etc " |
|
"host %s ns %s set for dataType=%u encoding=%u isPull=%s", |
|
(const char *)hn.getCString(), |
|
(const char *)ns.getString().getCString(), |
|
_dataType, _encoding, boolToString(isPullOperation) )); |
|
| |
if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) | if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY)) |
{ | { |
|
|
// -> usage: See resolveBinary() | // -> usage: See resolveBinary() |
_defaultNamespace=ns; | _defaultNamespace=ns; |
_defaultHostname=hn; | _defaultHostname=hn; |
count++; |
|
} | } |
// InternalXml does not support objectPath calls | // InternalXml does not support objectPath calls |
if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) && | if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) && |
|
|
if (0 == _hostsData[j].size()) | if (0 == _hostsData[j].size()) |
{ | { |
_hostsData[j]=hn; | _hostsData[j]=hn; |
count++; |
|
} | } |
if (_nameSpacesData[j].isNull()) | if (_nameSpacesData[j].isNull()) |
{ | { |
|
|
{ | { |
if (0 == _hostsData[j].size()) | if (0 == _hostsData[j].size()) |
{ | { |
count++; |
|
_hostsData[j]=hn; | _hostsData[j]=hn; |
} | } |
if (_nameSpacesData[j].isNull()) | if (_nameSpacesData[j].isNull()) |
|
|
const_cast<CIMObjectPath&>(instance.getPath()); | const_cast<CIMObjectPath&>(instance.getPath()); |
if (p.getHost().size()==0) | if (p.getHost().size()==0) |
{ | { |
count++; |
|
p.setHost(hn); | p.setHost(hn); |
} | } |
if (p.getNameSpace().isNull()) | if (p.getNameSpace().isNull()) |
|
|
const_cast<CIMObjectPath&>(object.getPath()); | const_cast<CIMObjectPath&>(object.getPath()); |
if (p.getHost().size()==0) | if (p.getHost().size()==0) |
{ | { |
count++; |
|
p.setHost(hn); | p.setHost(hn); |
} | } |
if (p.getNameSpace().isNull()) | if (p.getNameSpace().isNull()) |
|
|
CIMObjectPath& p = _instanceNames[j]; | CIMObjectPath& p = _instanceNames[j]; |
if (p.getHost().size() == 0) | if (p.getHost().size() == 0) |
{ | { |
count++; |
|
p.setHost(hn); | p.setHost(hn); |
} | } |
if (p.getNameSpace().isNull()) | if (p.getNameSpace().isNull()) |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
} | } |
|
|
{ | { |
for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++) | for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++) |
{ | { |
count++; |
|
SCMOInstance & scmoInst=_scmoInstances[j]; | SCMOInstance & scmoInst=_scmoInstances[j]; |
scmoInst.completeHostNameAndNamespace( | scmoInst.completeHostNameAndNamespace( |
hnChars, | hnChars, |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
} | } |
PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4, // KS_TODO TEMP |
|
"completeHostNameAndNamespace Set hostName, etc count %u" |
|
"host %s ns %s set for dataType=%u encoding=%u isPull=%s", |
|
count, |
|
(const char *)hn.getCString(), |
|
(const char *)ns.getString().getCString(), |
|
_dataType, _encoding, boolToString(isPullOperation) )); |
|
|
|
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
// NOTE: The reason for the isPullResponse variable is that there are | // NOTE: The reason for the isPullResponse variable is that there are |
// some variations in ouput to Xml depending on whether the responses | // some variations in ouput to Xml depending on whether the responses |
// are one of the pull responses or not | // are one of the pull responses or not |
void CIMResponseData::encodeXmlResponse(Buffer& out, Boolean isPullResponse) |
void CIMResponseData::encodeXmlResponse(Buffer& out, |
|
Boolean isPullResponse, |
|
Boolean encodeInstanceOnly) |
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, | PEG_METHOD_ENTER(TRC_DISPATCHER, |
"CIMResponseData::encodeXmlResponse"); | "CIMResponseData::encodeXmlResponse"); |
| |
PEG_TRACE((TRC_XML, Tracer::LEVEL3, | PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
"CIMResponseData::encodeXmlResponse(encoding=%X,dataType=%X, pull= %s)", |
"CIMResponseData::encodeXmlResponse(encoding=%X,dataType=%X, isPull= %s" |
|
" encodeInstanceOnly= %s)", |
_encoding, | _encoding, |
_dataType, | _dataType, |
(isPullResponse? "true" : "false"))); |
boolToString(isPullResponse), |
|
boolToString(encodeInstanceOnly) )); |
| |
// already existing Internal XML does not need to be encoded further | // already existing Internal XML does not need to be encoded further |
// binary input is not actually impossible here, but we have an established | // binary input is not actually impossible here, but we have an established |
|
|
{ | { |
if (isPullResponse) | if (isPullResponse) |
{ | { |
// KS_TODO these are temporary. delete before release |
out << STRLIT("<VALUE.INSTANCEWITHPATH>\n" |
PEGASUS_ASSERT(a.size() == b.size()); |
"<INSTANCEPATH>\n"); |
PEGASUS_ASSERT(a.size() == _hostsData.size()); |
|
PEGASUS_ASSERT(a.size() == _nameSpacesData.size()); |
|
|
|
out << STRLIT("<VALUE.INSTANCEWITHPATH>\n"); |
|
out << STRLIT("<INSTANCEPATH>\n"); |
|
XmlWriter::appendNameSpacePathElement(out, | XmlWriter::appendNameSpacePathElement(out, |
_hostsData[i], | _hostsData[i], |
_nameSpacesData[i]); | _nameSpacesData[i]); |
|
|
| |
for (Uint32 i = 0, n = a.size(); i < n; i++) | for (Uint32 i = 0, n = a.size(); i < n; i++) |
{ | { |
|
if (isPullResponse) |
|
{ |
|
out << STRLIT("<VALUE.INSTANCEWITHPATH>\n"); |
|
} |
|
else |
|
{ |
out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); | out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); |
|
} |
out << STRLIT("<INSTANCEPATH>\n"); | out << STRLIT("<INSTANCEPATH>\n"); |
XmlWriter::appendNameSpacePathElement( | XmlWriter::appendNameSpacePathElement( |
out, | out, |
_hostsData[i], | _hostsData[i], |
_nameSpacesData[i]); | _nameSpacesData[i]); |
|
|
|
if (isPullResponse) |
|
{ |
|
out.append((char*)b[i].getData(),b[i].size()-1); |
|
} |
|
else |
|
{ |
// Leave out the surrounding tags "<VALUE.REFERENCE>\n" | // Leave out the surrounding tags "<VALUE.REFERENCE>\n" |
// and "</VALUE.REFERENCE>\n" which are 18 and 19 characters |
// and "</VALUE.REFERENCE>\n" which are 18 and 19 |
// long |
// characters long |
|
//// KS_TODO Should be able to do this by properly |
|
//// building in the CIMXmlInternalEncoder |
out.append( | out.append( |
((char*)b[i].getData())+18, | ((char*)b[i].getData())+18, |
b[i].size() - 1 - 18 -19); | b[i].size() - 1 - 18 -19); |
|
} |
|
|
out << STRLIT("</INSTANCEPATH>\n"); | out << STRLIT("</INSTANCEPATH>\n"); |
// append instance body | // append instance body |
out.append((char*)a[i].getData(), a[i].size() - 1); | out.append((char*)a[i].getData(), a[i].size() - 1); |
|
if (isPullResponse) |
|
{ |
|
out << STRLIT("</VALUE.INSTANCEWITHPATH>\n"); |
|
} |
|
else |
|
{ |
out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); | out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); |
} | } |
|
} |
break; | break; |
} | } |
// internal xml encoding of instance names and object paths not | // internal xml encoding of instance names and object paths not |
|
|
{ | { |
if (isPullResponse) | if (isPullResponse) |
{ | { |
|
if (encodeInstanceOnly) |
|
{ |
|
XmlWriter::appendInstanceElement( |
|
out, |
|
_instances[i], |
|
_includeQualifiers, |
|
_includeClassOrigin, |
|
_propertyList); |
|
} |
|
else |
|
{ |
XmlWriter::appendValueInstanceWithPathElement( | XmlWriter::appendValueInstanceWithPathElement( |
out, | out, |
_instances[i], | _instances[i], |
|
|
_includeClassOrigin, | _includeClassOrigin, |
_propertyList); | _propertyList); |
} | } |
|
} |
else | else |
{ | { |
XmlWriter::appendValueNamedInstanceElement( | XmlWriter::appendValueNamedInstanceElement( |
|
|
// If pull, map to instances | // If pull, map to instances |
if (isPullResponse) | if (isPullResponse) |
{ | { |
|
|
CIMInstance x = (CIMInstance)_objects[i]; | CIMInstance x = (CIMInstance)_objects[i]; |
|
if (encodeInstanceOnly) |
|
{ |
|
XmlWriter::appendInstanceElement( |
|
out, |
|
x, |
|
_includeQualifiers, |
|
_includeClassOrigin, |
|
_propertyList); |
|
} |
|
else |
|
{ |
XmlWriter::appendValueInstanceWithPathElement( | XmlWriter::appendValueInstanceWithPathElement( |
out, x, |
out, |
|
x, |
_includeQualifiers, | _includeQualifiers, |
_includeClassOrigin, | _includeClassOrigin, |
_propertyList); | _propertyList); |
} | } |
|
} |
else | else |
{ | { |
XmlWriter::appendValueObjectWithPathElement( | XmlWriter::appendValueObjectWithPathElement( |
|
|
for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++) | for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++) |
{ | { |
// ObjectPaths come from providers for pull operations | // ObjectPaths come from providers for pull operations |
// but are encoded as instancePathElements |
// but are encoded as instancePathElements. If pull |
|
// only instances allowed. |
if (isPullResponse) | if (isPullResponse) |
|
|
{ | { |
XmlWriter::appendInstancePathElement(out, |
XmlWriter::appendInstancePathElement( |
|
out, |
_instanceNames[i]); | _instanceNames[i]); |
} | } |
else | else |
{ | { |
|
//Append The path element (Class or instance) |
out << "<OBJECTPATH>\n"; | out << "<OBJECTPATH>\n"; |
XmlWriter::appendValueReferenceElement( |
XmlWriter::appendClassOrInstancePathElement( |
out, | out, |
_instanceNames[i], | _instanceNames[i], |
_isClassOperation, |
_isClassOperation); |
false); |
|
out << "</OBJECTPATH>\n"; | out << "</OBJECTPATH>\n"; |
} | } |
} | } |
|
|
{ | { |
case RESP_INSTNAMES: | case RESP_INSTNAMES: |
{ | { |
if (isPullResponse) |
|
{ |
|
for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) | for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) |
{ | { |
|
if (isPullResponse) |
|
{ |
SCMOXmlWriter::appendInstancePathElement( | SCMOXmlWriter::appendInstancePathElement( |
out, | out, |
_scmoInstances[i]); | _scmoInstances[i]); |
|
|
} |
|
} | } |
else | else |
{ | { |
for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++) |
|
{ |
|
SCMOXmlWriter::appendInstanceNameElement( | SCMOXmlWriter::appendInstanceNameElement( |
out, | out, |
_scmoInstances[i]); | _scmoInstances[i]); |
|
|
} | } |
} | } |
break; | break; |
|
|
{ | { |
if (_scmoInstances.size() > 0) | if (_scmoInstances.size() > 0) |
{ | { |
if(_propertyList.isNull()) |
_appendInstanceElement(out, _scmoInstances[0]); |
{ |
|
Array<Uint32> emptyNodes; |
|
SCMOXmlWriter::appendInstanceElement( |
|
out, |
|
_scmoInstances[0], |
|
false, |
|
emptyNodes); |
|
} |
|
else |
|
{ |
|
Array<propertyFilterNodesArray_t> propFilterNodesArrays; |
|
// This searches for an already created array of nodes, |
|
//if not found, creates it inside propFilterNodesArrays |
|
const Array<Uint32> & nodes= |
|
SCMOXmlWriter::getFilteredNodesArray( |
|
propFilterNodesArrays, |
|
_scmoInstances[0], |
|
_propertyList); |
|
SCMOXmlWriter::appendInstanceElement( |
|
out, |
|
_scmoInstances[0], |
|
true, |
|
nodes); |
|
} |
|
} | } |
break; | break; |
} | } |
|
|
{ | { |
if (isPullResponse) | if (isPullResponse) |
{ | { |
|
// pull and encodeInstanceOnly (i.e. response to |
|
// OpenQueryInstances and pullInstances |
|
if (encodeInstanceOnly) |
|
{ |
|
// KS_FUTURE move this to SCMOXmlWriter |
|
for (Uint32 i = 0, n = _scmoInstances.size();i < n; i++) |
|
{ |
|
_appendInstanceElement(out, _scmoInstances[i]); |
|
} |
|
} |
|
else |
|
{ |
SCMOXmlWriter::appendValueSCMOInstanceWithPathElements( | SCMOXmlWriter::appendValueSCMOInstanceWithPathElements( |
out, _scmoInstances, _propertyList); | out, _scmoInstances, _propertyList); |
} | } |
|
} |
else | else |
{ | { |
SCMOXmlWriter::appendValueSCMOInstanceElements( | SCMOXmlWriter::appendValueSCMOInstanceElements( |
|
|
{ | { |
if (isPullResponse) | if (isPullResponse) |
{ | { |
|
// if encodeInstanceOnly flag, encode objects as instances |
|
// Used by OpenQueryInstances and pullInstances. |
|
if (encodeInstanceOnly) |
|
{ |
|
for (Uint32 i = 0, n = _scmoInstances.size();i < n; i++) |
|
{ |
|
_appendInstanceElement(out, _scmoInstances[i]); |
|
} |
|
} |
|
else |
|
{ |
SCMOXmlWriter::appendValueSCMOInstanceWithPathElements( | SCMOXmlWriter::appendValueSCMOInstanceWithPathElements( |
out,_scmoInstances, _propertyList); | out,_scmoInstances, _propertyList); |
} | } |
|
} |
else | else |
{ | { |
// KS_TODO why is this one named element rather than | // KS_TODO why is this one named element rather than |
|
|
else | else |
{ | { |
out << "<OBJECTPATH>\n"; | out << "<OBJECTPATH>\n"; |
SCMOXmlWriter::appendValueReferenceElement( |
SCMOXmlWriter::appendClassOrInstancePathElement( |
out, _scmoInstances[i], |
out, _scmoInstances[i]); |
false); |
|
out << "</OBJECTPATH>\n"; | out << "</OBJECTPATH>\n"; |
} | } |
} | } |
|
|
} | } |
} | } |
} | } |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
// contrary to encodeXmlResponse this function encodes the Xml in a format | // contrary to encodeXmlResponse this function encodes the Xml in a format |
// not usable by clients | // not usable by clients |
void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out) |
void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out, |
|
Boolean isPullOperation) |
{ | { |
PEG_METHOD_ENTER(TRC_DISPATCHER, | PEG_METHOD_ENTER(TRC_DISPATCHER, |
"CIMResponseData::encodeInternalXmlResponse"); | "CIMResponseData::encodeInternalXmlResponse"); |
| |
PEG_TRACE((TRC_XML, Tracer::LEVEL3, | PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
"CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)", |
"CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X" |
|
" isPullOperation=%s)", |
_encoding, | _encoding, |
_dataType)); |
_dataType, |
|
boolToString(isPullOperation))); |
|
|
// For mixed (CIM+SCMO) responses, we need to tell the receiver the | // For mixed (CIM+SCMO) responses, we need to tell the receiver the |
// total number of instances. The totalSize variable is used to keep track | // total number of instances. The totalSize variable is used to keep track |
// of this. | // of this. |
|
|
out.putUint32(totalSize); | out.putUint32(totalSize); |
for (Uint32 i = 0; i < n; i++) | for (Uint32 i = 0; i < n; i++) |
{ | { |
|
// if is pull map to instances. |
|
if (isPullOperation) |
|
{ |
|
CIMInternalXmlEncoder::_putXMLNamedInstance( |
|
out, |
|
(CIMInstance)_objects[i], |
|
_includeQualifiers, |
|
_includeClassOrigin, |
|
_propertyList); |
|
} |
|
else |
|
{ |
CIMInternalXmlEncoder::_putXMLObject( | CIMInternalXmlEncoder::_putXMLObject( |
out, | out, |
_objects[i], | _objects[i], |
|
|
_includeClassOrigin, | _includeClassOrigin, |
_propertyList); | _propertyList); |
} | } |
|
} |
break; | break; |
} | } |
// internal xml encoding of instance names and object paths not | // internal xml encoding of instance names and object paths not |
|
|
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
} | } |
|
|
{ | { |
out.putUint32(n); | out.putUint32(n); |
} | } |
|
// if is pull map to instances. |
|
if (isPullOperation) |
|
{ |
|
SCMOInternalXmlEncoder::_putXMLNamedInstance( |
|
out, |
|
_scmoInstances, |
|
_propertyList); |
|
} |
|
else |
|
{ |
SCMOInternalXmlEncoder::_putXMLObject( | SCMOInternalXmlEncoder::_putXMLObject( |
out, | out, |
_scmoInstances, | _scmoInstances, |
_propertyList); | _propertyList); |
|
} |
break; | break; |
} | } |
// internal xml encoding of instance names and object paths not | // internal xml encoding of instance names and object paths not |
|
|
case RESP_OBJECTPATHS: | case RESP_OBJECTPATHS: |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
} | } |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} // switch | } // switch |
_encoding |= RESP_ENC_CIM; | _encoding |= RESP_ENC_CIM; |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
_scmoInstances.clear(); | _scmoInstances.clear(); |
|
|
} | } |
default: | default: |
{ | { |
PEGASUS_ASSERT(false); |
PEGASUS_DEBUG_ASSERT(false); |
} | } |
} | } |
| |
|
|
_isClassOperation = b; | _isClassOperation = b; |
} | } |
| |
//// KS_TODO Remove. Diagnostic Display |
// Clear all of the input encodings by clearing their arrays and |
void CIMResponseData::traceResponseData() |
// unsetting the encoding flag. |
|
void CIMResponseData::clear() |
|
{ |
|
// Clear the xml data area |
|
_referencesData.clear(); |
|
_hostsData.clear(); |
|
_nameSpacesData.clear(); |
|
_instanceData.clear(); |
|
|
|
// Clear the binary data area |
|
_binaryData.clear(); |
|
|
|
// Clear the SCMO data |
|
_scmoInstances.clear(); |
|
|
|
//Clear the C++ Data areaa |
|
_instanceNames.clear(); |
|
_instances.clear(); |
|
_objects.clear(); |
|
|
|
_encoding = 0; |
|
_size = 0; |
|
} |
|
|
|
// The following are debugging support only |
|
//// FUTURE: Make this conditional compile |
|
void CIMResponseData::traceResponseData() const |
{ | { |
PEG_TRACE((TRC_XML, Tracer::LEVEL3, | PEG_TRACE((TRC_XML, Tracer::LEVEL3, |
|
"%s", (const char*)toStringTraceResponseData().getCString() )); |
|
} |
|
|
|
String CIMResponseData::toStringTraceResponseData() const |
|
{ |
|
String rtnStr; |
|
rtnStr.appendPrintf( |
"CIMResponseData::traceResponseData(encoding=%X,dataType=%X " | "CIMResponseData::traceResponseData(encoding=%X,dataType=%X " |
" size=%u C++instNamecount=%u c++Instances=%u c++Objects=%u " | " size=%u C++instNamecount=%u c++Instances=%u c++Objects=%u " |
"scomInstances=%u XMLInstData=%u binaryData=%u " | "scomInstances=%u XMLInstData=%u binaryData=%u " |
|
|
_instanceNames.size(),_instances.size(), _objects.size(), | _instanceNames.size(),_instances.size(), _objects.size(), |
_scmoInstances.size(),_instanceData.size(),_binaryData.size(), | _scmoInstances.size(),_instanceData.size(),_binaryData.size(), |
_referencesData.size(), _instanceData.size(), _hostsData.size(), | _referencesData.size(), _instanceData.size(), _hostsData.size(), |
_nameSpacesData.size() )); |
_nameSpacesData.size()); |
|
|
|
return(rtnStr); |
} | } |
| |
|
|
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |