(file) Return to CIMOperationResponseEncoder.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Server

Diff for /pegasus/src/Pegasus/Server/CIMOperationResponseEncoder.cpp between version 1.51 and 1.52

version 1.51, 2004/10/17 20:40:12 version 1.52, 2004/11/05 15:44:06
Line 40 
Line 40 
 //              Seema Gupta (gseema@in.ibm.com) for PEP135 //              Seema Gupta (gseema@in.ibm.com) for PEP135
 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
 //                              Willis White (whiwill@us.ibm.com) PEP 127 and 128 //                              Willis White (whiwill@us.ibm.com) PEP 127 and 128
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 47 
Line 48 
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <cctype> #include <cctype>
 #include <cstdio> #include <cstdio>
   #include <Pegasus/Common/HTTPConnection.h>
 #include <Pegasus/Common/XmlParser.h> #include <Pegasus/Common/XmlParser.h>
 #include <Pegasus/Common/XmlReader.h> #include <Pegasus/Common/XmlReader.h>
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
Line 82 
Line 84 
  
 } }
  
 void CIMOperationResponseEncoder::sendResponse  void
 (Uint32 queueId, Array<Sint8>& message, Boolean isLast, Uint32 messageIndex,  CIMOperationResponseEncoder::sendResponse(CIMResponseMessage* response,
  const CIMException* cimException)                                                                                                                                                                          const String &name,
                                                                                                                                                                           Boolean isImplicit,
                                                                                                                                                                           Array<Sint8> *bodygiven)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,          static String funcname = "CIMOperationResponseEncoder::sendResponse: ";
                     "CIMOperationResponseEncoder::sendResponse()");          PEG_METHOD_ENTER(TRC_DISPATCHER, String(funcname + "for class " + name).getCString());
    MessageQueue* queue = MessageQueue::lookup(queueId);  
  
    if (queue)          if (! response)
    {    {
                   CIMException cimExceptionDescription;                  PEG_METHOD_EXIT();
                         if (cimException && cimException->getCode() != CIM_ERR_SUCCESS)                  return;
                         {  
                                 String msg = XmlWriter::encodeURICharacters  
                                         (TraceableCIMException(*cimException).getDescription());  
                                 cimExceptionDescription = CIMException(cimException->getCode(), msg);  
                         }                         }
       AutoPtr<HTTPMessage> httpMessage(new HTTPMessage  
                                                                                                                                                          (message, 0, &cimExceptionDescription));  
                         httpMessage->setComplete(isLast);  
                         httpMessage->setIndex(messageIndex);  
       Tracer::traceBuffer(TRC_XML_IO, Tracer::LEVEL2,  
                           httpMessage->message.getData(), httpMessage->message.size());  
  
       Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          Uint32 queueId = response->queueIds.top();
                   "CIMOperationResponseEncoder::SendResponse - QueueId: $0  XML content: $1",          response->queueIds.pop();
                                                                         queueId,  
                   String(httpMessage->message.getData(),httpMessage->message.size()));  
  
       queue->enqueue(httpMessage.release());          MessageQueue* queue = MessageQueue::lookup(queueId);
  
 #ifdef PEGASUS_CCOVER          if (!queue)
       cov_write();  
 #endif  
    }  
    else  
    {    {
       Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,       Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                     "Invalid queueId = %i, response not sent.", queueId);                                                                          "ERROR: non-existent queueId = %u, response not sent.", queueId);
                   PEG_METHOD_EXIT();
                   return;
    }    }
  
           HTTPConnection *httpQueue = dynamic_cast<HTTPConnection *>(queue);
   
           if (! httpQueue)
           {
                   Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                                                                           "ERROR: Unknown queue type. queueId = %u, response not sent.",
                                                                           queueId);
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
                   return;
 } }
  
 // Code is duplicated in CIMOperationRequestDecoder          Boolean isChunkRequest = httpQueue->isChunkRequested();
 void CIMOperationResponseEncoder::sendIMethodError(          HttpMethod httpMethod = response->getHttpMethod();
    Uint32 queueId,          String &messageId = response->messageId;
           CIMException &cimException = response->cimException;
           Array<Sint8> message;
           const OperationContext::Container &container =
                   response->operationContext.get(ContentLanguageListContainer::NAME);
           const ContentLanguageListContainer &listContainer =
                   *dynamic_cast<const ContentLanguageListContainer *>(&container);
           ContentLanguages language = listContainer.getLanguages();
           CIMName cimName(name);
           Uint32 messageIndex = response->getIndex();
           Boolean isFirst = messageIndex == 0 ? true : false;
           Boolean isLast = response->isComplete();
           Uint64 serverTime       = response->totServerTime;
           Array<Sint8> bodylocal;
           Array<Sint8> &body = bodygiven ? *bodygiven : bodylocal;
   
           Array<Sint8> (*formatResponse)(const CIMName& iMethodName,
                                                                                                                                    const String& messageId,
    HttpMethod httpMethod,    HttpMethod httpMethod,
                                                                                                                                    const ContentLanguages &httpContentLanguages,
                                                                                                                                    const Array<Sint8>& body,
                                                                                                                                    Uint64 serverResponseTime,
                                                                                                                                    Boolean isFirst,
                                                                                                                                    Boolean isLast);
   
           Array<Sint8> (*formatError)(const CIMName& methodName,
    const String& messageId,    const String& messageId,
    const String& iMethodName,                                                                                                                          HttpMethod httpMethod,
    const CIMException& cimException,                                                                                                                          const CIMException& cimException);
          Uint32 messageIndex)  
           if (isImplicit == false)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                  formatResponse = XmlWriter::formatSimpleMethodRspMessage;
                      "CIMOperationResponseEncoder::sendIMethodError()");                  formatError = XmlWriter::formatSimpleMethodErrorRspMessage;
           }
           else
           {
                   formatResponse = XmlWriter::formatSimpleIMethodRspMessage;
                   formatError = XmlWriter::formatSimpleIMethodErrorRspMessage;
           }
  
     Array<Sint8> message;          if (cimException.getCode() != CIM_ERR_SUCCESS)
     message = XmlWriter::formatSimpleIMethodErrorRspMessage(          {
         iMethodName,                  STAT_SERVEREND_ERROR
         messageId,  
         httpMethod,  
         cimException);  
  
     sendResponse(queueId, message, true, messageIndex, &cimException);                  if (httpQueue->cimException.getCode() == CIM_ERR_SUCCESS)
                   {
  
     PEG_METHOD_EXIT();                          if (isChunkRequest == false)
 }                                  message = formatError(name, messageId, httpMethod, cimException);
  
 void CIMOperationResponseEncoder::sendIMethodError(                          // uri encode the error (for the http header) only when it is
    CIMResponseMessage* response,                          // non-chunking or the first error with chunking
    const String& cimMethodName)                          if (isChunkRequest == false || (isChunkRequest == true && isFirst == true))
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,                                  String msg = TraceableCIMException(cimException).getDescription();
                     "CIMOperationResponseEncoder::sendIMethodError()");                                  String uriEncodedMsg = XmlWriter::encodeURICharacters(msg);
                                   cimException = CIMException(cimException.getCode(), uriEncodedMsg);
                           }
  
    Uint32 queueId = response->queueIds.top();                  } // if first error in response stream
    response->queueIds.pop();  
  
    sendIMethodError(                  // never put the error in chunked response (because it will end up in
       queueId,                  // the trailer), so just use the non-error response formatter so send
       response->getHttpMethod(),                  // more data
       response->messageId,  
       cimMethodName,  
       response->cimException,  
                         response->getIndex());  
  
    PEG_METHOD_EXIT();                  if (isChunkRequest == true)
                   {
                           message = formatResponse(cimName, messageId, httpMethod,
                                                                                                                            language, body, serverTime, isFirst, isLast);
                   }
           }
           else
           {
                   // else non-error condition
                   STAT_SERVEREND
                   try
                   {
                           message = formatResponse(cimName, messageId, httpMethod,
                                                                                                                            language, body, serverTime, isFirst, isLast);
 } }
  
 void CIMOperationResponseEncoder::sendMethodError(  #ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC
    Uint32 queueId,     catch (std::bad_alloc&)
    HttpMethod httpMethod,  #else
    const String& messageId,     catch (bad_alloc&)
    const CIMName& methodName,  #endif
    const CIMException& cimException,  
          Uint32 messageIndex)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                   Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
                      "CIMOperationResponseEncoder::sendMethodError()");                                                                   funcname + OUT_OF_MEMORY_MESSAGE);
  
     Array<Sint8> message;                   cimException = PEGASUS_CIM_EXCEPTION_L
     message = XmlWriter::formatSimpleMethodErrorRspMessage(                           (CIM_ERR_FAILED,
         methodName,                                  MessageLoaderParms("Server.CIMOperationResponseEncoder.OUT_OF_MEMORY",
         messageId,                                                                                                           OUT_OF_MEMORY_MESSAGE));
         httpMethod,                   response->cimException = cimException;
         cimException);                   // try again with new error and no body
                    body.clear();
                    sendResponse(response, name, isImplicit);
                    return;
            }
  
     sendResponse(queueId, message, true, messageIndex, &cimException);           STAT_BYTESSENT
  
     PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::sendMethodError(          AutoPtr<HTTPMessage> httpMessage(new HTTPMessage(message, 0, &cimException));
    CIMResponseMessage* response,          httpMessage->setComplete(isLast);
    const CIMName& cimMethodName)          httpMessage->setIndex(messageIndex);
 {          Tracer::traceBuffer(TRC_XML_IO, Tracer::LEVEL2,
    PEG_METHOD_ENTER(TRC_DISPATCHER,                                                                                          httpMessage->message.getData(),
                     "CIMOperationResponseEncoder::sendMethodError()");                                                                                          httpMessage->message.size());
  
    Uint32 queueId = response->queueIds.top();          Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
    response->queueIds.pop();                                                          "CIMOperationResponseEncoder::sendResponse - QueueId: $0  "
                                                           "XML content: $1",queueId,
                                                           String(message.getData(), message.size()));
   
           queue->enqueue(httpMessage.release());
   
   #ifdef PEGASUS_CCOVER
           cov_write();
   #endif
  
    sendMethodError(  
       queueId,  
       response->getHttpMethod(),  
       response->messageId,  
       cimMethodName,  
       response->cimException,  
                         response->getIndex());  
    PEG_METHOD_EXIT();    PEG_METHOD_EXIT();
 } }
  
Line 370 
Line 408 
 void CIMOperationResponseEncoder::encodeCreateClassResponse( void CIMOperationResponseEncoder::encodeCreateClassResponse(
    CIMCreateClassResponseMessage* response)    CIMCreateClassResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,          sendResponse(response, "CreateClass", true);
                     "CIMOperationResponseEncoder::encodeCreateClassResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "CreateClass");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
         STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("CreateClass"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
   
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeGetClassResponse( void CIMOperationResponseEncoder::encodeGetClassResponse(
    CIMGetClassResponseMessage* response)    CIMGetClassResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,  
                     "CIMOperationResponseEncoder::encodeGetClassResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "GetClass");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
           if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    XmlWriter::appendClassElement(body, response->cimClass);    XmlWriter::appendClassElement(body, response->cimClass);
           sendResponse(response, "GetClass", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("GetClass"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
   
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeModifyClassResponse( void CIMOperationResponseEncoder::encodeModifyClassResponse(
    CIMModifyClassResponseMessage* response)    CIMModifyClassResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,          sendResponse(response, "ModifyClass", true);
                     "CIMOperationResponseEncoder::encodeModifyClassResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "ModifyClass");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("ModifyClass"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
   
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeEnumerateClassNamesResponse( void CIMOperationResponseEncoder::encodeEnumerateClassNamesResponse(
    CIMEnumerateClassNamesResponseMessage* response)    CIMEnumerateClassNamesResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeEnumerateClassNamesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "EnumerateClassNames");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
           if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->classNames.size(); i++)                  for (Uint32 i = 0, n = response->classNames.size(); i < n; i++)
       XmlWriter::appendClassNameElement(body, response->classNames[i]);       XmlWriter::appendClassNameElement(body, response->classNames[i]);
           sendResponse(response, "EnumerateClassNames", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("EnumerateClassNames"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
   
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeEnumerateClassesResponse( void CIMOperationResponseEncoder::encodeEnumerateClassesResponse(
    CIMEnumerateClassesResponseMessage* response)    CIMEnumerateClassesResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeEnumerateClassesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "EnumerateClasses");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
    Array<Sint8> message;          if (response->cimException.getCode() == CIM_ERR_SUCCESS)
                   for (Uint32 i = 0, n= response->cimClasses.size(); i < n; i++)
    try  
    {  
        for (Uint32 i = 0; i < response->cimClasses.size(); i++)  
           XmlWriter::appendClassElement(body, response->cimClasses[i]);           XmlWriter::appendClassElement(body, response->cimClasses[i]);
           sendResponse(response, "EnumerateClasses", true, &body);
            STAT_SERVEREND  
   
        message = XmlWriter::formatSimpleIMethodRspMessage(  
           CIMName ("EnumerateClasses"), response->messageId,  
           response->getHttpMethod(),  
                           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
           body,  
                   response->totServerTime);  
   
        STAT_BYTESSENT  
    }  
    // This operation may result in a large response. Handle the bad_alloc  
    // exception and send an error response.  
   
 #ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC  
    catch (std::bad_alloc&)  
 #else  
    catch (bad_alloc&)  
 #endif  
    {  
        // ATTN-SF-P5-20021004 A message should be logged here  
        // indicating the out of memory message.  
   
      // l10n  
      CIMException cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,  
                                   MessageLoaderParms(  
                                     "Server.CIMOperationResponseEncoder.OUT_OF_MEMORY",  
                                      OUT_OF_MEMORY_MESSAGE));  
   
      // CIMException cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
      //                            OUT_OF_MEMORY_MESSAGE);  
   
        response->cimException = cimException;  
        sendIMethodError(response, "EnumerateClasses");  
        PEG_METHOD_EXIT();  
        return;  
    }  
   
        sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
        PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeDeleteClassResponse( void CIMOperationResponseEncoder::encodeDeleteClassResponse(
    CIMDeleteClassResponseMessage* response)    CIMDeleteClassResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,          sendResponse(response, "DeleteClass", true);
                     "CIMOperationResponseEncoder::encodeDeleteClassResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "DeleteClass");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("DeleteClass"), response->messageId,  
       response->getHttpMethod(),  
                   ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeCreateInstanceResponse( void CIMOperationResponseEncoder::encodeCreateInstanceResponse(
    CIMCreateInstanceResponseMessage* response)    CIMCreateInstanceResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeCreateInstanceResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "CreateInstance");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    XmlWriter::appendInstanceNameElement(body, response->instanceName);    XmlWriter::appendInstanceNameElement(body, response->instanceName);
            sendResponse(response, "CreateInstance", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("CreateInstance"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeGetInstanceResponse( void CIMOperationResponseEncoder::encodeGetInstanceResponse(
    CIMGetInstanceResponseMessage* response)    CIMGetInstanceResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeGetInstanceResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "GetInstance");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    XmlWriter::appendInstanceElement(body, response->cimInstance);    XmlWriter::appendInstanceElement(body, response->cimInstance);
            sendResponse(response, "GetInstance", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("GetInstance"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeModifyInstanceResponse( void CIMOperationResponseEncoder::encodeModifyInstanceResponse(
    CIMModifyInstanceResponseMessage* response)    CIMModifyInstanceResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"          sendResponse(response, "ModifyInstance", true);
                     "encodeModifyInstanceResponse()");  }
  
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  void CIMOperationResponseEncoder::encodeEnumerateInstancesResponse(
      CIMEnumerateInstancesResponseMessage* response)
    {    {
       STAT_SERVEREND_ERROR          Array<Sint8> body;
           if (response->cimException.getCode() == CIM_ERR_SUCCESS)
       sendIMethodError(response, "ModifyInstance");                  for (Uint32 i = 0, n = response->cimNamedInstances.size(); i < n; i++)
       PEG_METHOD_EXIT();                          XmlWriter::appendValueNamedInstanceElement(body, response->cimNamedInstances[i]);
       return;          sendResponse(response, "EnumerateInstances", true, &body);
    }    }
  
   void CIMOperationResponseEncoder::encodeEnumerateInstanceNamesResponse(
      CIMEnumerateInstanceNamesResponseMessage* response)
   {
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
                    for (Uint32 i = 0, n = response->instanceNames.size(); i < n; i++)
                            XmlWriter::appendInstanceNameElement(body, response->instanceNames[i]);
            sendResponse(response, "EnumerateInstanceNames", true, &body);
   }
  
    STAT_SERVEREND  void CIMOperationResponseEncoder::encodeDeleteInstanceResponse(
      CIMDeleteInstanceResponseMessage* response)
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  {
       CIMName ("ModifyInstance"), response->messageId,          sendResponse(response, "DeleteInstance", true);
       response->getHttpMethod(),  }
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 }  
   
 void CIMOperationResponseEncoder::encodeEnumerateInstancesResponse(  
    CIMEnumerateInstancesResponseMessage* response)  
 {  
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeEnumerateInstancesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "EnumerateInstances");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
    Array<Sint8> message;  
   
   
    try  
    {  
        for (Uint32 i = 0; i < response->cimNamedInstances.size(); i++)  
           XmlWriter::appendValueNamedInstanceElement(  
               body, response->cimNamedInstances[i]);  
   
            STAT_SERVEREND  
        message = XmlWriter::formatSimpleIMethodRspMessage(  
           CIMName ("EnumerateInstances"), response->messageId,  
           response->getHttpMethod(),  
                   ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
           body, response->totServerTime,  
                   response->isFirst(), response->isComplete());  
   
   
    }  
    // This operation may result in a large response. Handle the bad_alloc  
    // exception and send an error response.  
   
 #ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC  
    catch (std::bad_alloc&)  
 #else  
    catch (bad_alloc&)  
 #endif  
    {  
        // ATTN-SF-P5-20021004 A message should be logged here  
        // indicating the out of memory message.  
   
   
      // l10n  
      CIMException cimException = PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,  
                                      MessageLoaderParms(  
                                         "Server.CIMOperationResponseEncoder.OUT_OF_MEMORY",  
                                          OUT_OF_MEMORY_MESSAGE));  
   
        // CIMException cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
        //                            OUT_OF_MEMORY_MESSAGE);  
   
        response->cimException = cimException;  
        sendIMethodError(response, "EnumerateInstances");  
        PEG_METHOD_EXIT();  
        return;  
    }  
   
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 }  
   
 void CIMOperationResponseEncoder::encodeEnumerateInstanceNamesResponse(  
    CIMEnumerateInstanceNamesResponseMessage* response)  
 {  
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeEnumerateInstanceNamesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "EnumerateInstanceNames");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    for (Uint32 i = 0; i < response->instanceNames.size(); i++)  
       XmlWriter::appendInstanceNameElement(body, response->instanceNames[i]);  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("EnumerateInstanceNames"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body, response->totServerTime,  
           response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 }  
   
 void CIMOperationResponseEncoder::encodeDeleteInstanceResponse(  
    CIMDeleteInstanceResponseMessage* response)  
 {  
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeDeleteInstanceResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "DeleteInstance");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("DeleteInstance"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 }  
  
 void CIMOperationResponseEncoder::encodeGetPropertyResponse( void CIMOperationResponseEncoder::encodeGetPropertyResponse(
    CIMGetPropertyResponseMessage* response)    CIMGetPropertyResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,  
                     "CIMOperationResponseEncoder::encodeGetPropertyResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "GetProperty");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
           if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    XmlWriter::appendValueElement(body, response->value);    XmlWriter::appendValueElement(body, response->value);
           sendResponse(response, "GetProperty", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("GetProperty"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeSetPropertyResponse( void CIMOperationResponseEncoder::encodeSetPropertyResponse(
    CIMSetPropertyResponseMessage* response)    CIMSetPropertyResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,          sendResponse(response, "SetProperty", true);
                     "CIMOperationResponseEncoder::encodeSetPropertyResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "SetProperty");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("SetProperty"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeSetQualifierResponse( void CIMOperationResponseEncoder::encodeSetQualifierResponse(
    CIMSetQualifierResponseMessage* response)    CIMSetQualifierResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"          sendResponse(response, "SetQualifier", true);
                     "encodeSetQualifierResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "SetQualifier");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("SetQualifier"), response->messageId,  
       response->getHttpMethod(),  
                   ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeGetQualifierResponse( void CIMOperationResponseEncoder::encodeGetQualifierResponse(
    CIMGetQualifierResponseMessage* response)    CIMGetQualifierResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeGetQualifierResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "GetQualifier");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
           if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    XmlWriter::appendQualifierDeclElement(body, response->cimQualifierDecl);    XmlWriter::appendQualifierDeclElement(body, response->cimQualifierDecl);
           sendResponse(response, "GetQualifier", true, &body);
         STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("GetQualifier"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeEnumerateQualifiersResponse( void CIMOperationResponseEncoder::encodeEnumerateQualifiersResponse(
    CIMEnumerateQualifiersResponseMessage* response)    CIMEnumerateQualifiersResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeEnumerateQualifierResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "EnumerateQualifiers");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->qualifierDeclarations.size(); i++)                   for (Uint32 i = 0, n = response->qualifierDeclarations.size(); i < n;i++)
       XmlWriter::appendQualifierDeclElement(body, response->qualifierDeclarations[i]);       XmlWriter::appendQualifierDeclElement(body, response->qualifierDeclarations[i]);
            sendResponse(response, "EnumerateQualifiers", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("EnumerateQualifiers"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeDeleteQualifierResponse( void CIMOperationResponseEncoder::encodeDeleteQualifierResponse(
    CIMDeleteQualifierResponseMessage* response)    CIMDeleteQualifierResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"          sendResponse(response, "DeleteQualifier", true);
                     "encodeDeleteQualifierResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "DeleteQualifier");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;  
   
         STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("DeleteQualifier"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeReferenceNamesResponse( void CIMOperationResponseEncoder::encodeReferenceNamesResponse(
    CIMReferenceNamesResponseMessage* response)    CIMReferenceNamesResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeReferenceNamesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "ReferenceNames");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->objectNames.size(); i++)                   for (Uint32 i = 0, n = response->objectNames.size(); i < n; i++)
    {    {
       body << "<OBJECTPATH>\n";       body << "<OBJECTPATH>\n";
       XmlWriter::appendValueReferenceElement(body, response->objectNames[i], false);                           XmlWriter::appendValueReferenceElement(body, response->objectNames[i],
                                                                                                                                                                                           false);
       body << "</OBJECTPATH>\n";       body << "</OBJECTPATH>\n";
    }    }
            sendResponse(response, "ReferenceNames", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("ReferenceNames"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body, response->totServerTime,  
           response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeReferencesResponse( void CIMOperationResponseEncoder::encodeReferencesResponse(
    CIMReferencesResponseMessage* response)    CIMReferencesResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,  
                     "CIMOperationResponseEncoder::encodeReferencesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "References");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->cimObjects.size(); i++)                   for (Uint32 i = 0, n = response->cimObjects.size(); i < n;i++)
       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);
            sendResponse(response, "References", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("References"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body, response->totServerTime,  
           response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeAssociatorNamesResponse( void CIMOperationResponseEncoder::encodeAssociatorNamesResponse(
    CIMAssociatorNamesResponseMessage* response)    CIMAssociatorNamesResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeAssociatorNamesResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "AssociatorNames");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->objectNames.size(); i++)                   for (Uint32 i = 0, n = response->objectNames.size(); i < n; i++)
    {    {
       body << "<OBJECTPATH>\n";       body << "<OBJECTPATH>\n";
       XmlWriter::appendValueReferenceElement(body, response->objectNames[i], false);       XmlWriter::appendValueReferenceElement(body, response->objectNames[i], false);
       body << "</OBJECTPATH>\n";       body << "</OBJECTPATH>\n";
    }    }
            sendResponse(response, "AssociatorNames", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("AssociatorNames"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body, response->totServerTime,  
           response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeAssociatorsResponse( void CIMOperationResponseEncoder::encodeAssociatorsResponse(
    CIMAssociatorsResponseMessage* response)    CIMAssociatorsResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,  
                     "CIMOperationResponseEncoder::encodeAssociatorsResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "Associators");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->cimObjects.size(); i++)                   for (Uint32 i = 0, n = response->cimObjects.size(); i < n; i++)
       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);
            sendResponse(response, "Associators", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("Associators"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body, response->totServerTime,  
           response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeExecQueryResponse( void CIMOperationResponseEncoder::encodeExecQueryResponse(
    CIMExecQueryResponseMessage* response)    CIMExecQueryResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER,  
                     "CIMOperationResponseEncoder::encodeExecQueryResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendIMethodError(response, "ExecQuery");  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    for (Uint32 i = 0; i < response->cimObjects.size(); i++)    for (Uint32 i = 0; i < response->cimObjects.size(); i++)
       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);       XmlWriter::appendValueObjectWithPathElement(body, response->cimObjects[i]);
            sendResponse(response, "ExecQuery", true, &body);
    STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleIMethodRspMessage(  
       CIMName ("ExecQuery"), response->messageId,  
       response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
       body,  
           response->totServerTime);  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 void CIMOperationResponseEncoder::encodeInvokeMethodResponse( void CIMOperationResponseEncoder::encodeInvokeMethodResponse(
     CIMInvokeMethodResponseMessage* response)     CIMInvokeMethodResponseMessage* response)
 { {
    PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMOperationResponseEncoder::"  
                     "encodeInvokeMethodResponse()");  
   
    if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
    {  
       STAT_SERVEREND_ERROR  
   
       sendMethodError(response, response->methodName);  
       PEG_METHOD_EXIT();  
       return;  
    }  
   
    Array<Sint8> body;    Array<Sint8> body;
  
    // ATTN-RK-P3-20020219: Who's job is it to make sure the return value is    // ATTN-RK-P3-20020219: Who's job is it to make sure the return value is
    // not an array?    // not an array?
    // Only add the return value if it is not null    // Only add the return value if it is not null
    if (!response->retValue.isNull())  
            if (response->cimException.getCode() == CIM_ERR_SUCCESS)
    {    {
                    if (!response->retValue.isNull())
       XmlWriter::appendReturnValueElement(body, response->retValue);       XmlWriter::appendReturnValueElement(body, response->retValue);
    }  
  
    for (Uint32 i=0; i < response->outParameters.size(); i++)                   for (Uint32 i=0, n = response->outParameters.size(); i < n; i++)
    {  
       XmlWriter::appendParamValueElement(body, response->outParameters[i]);       XmlWriter::appendParamValueElement(body, response->outParameters[i]);
    }    }
            sendResponse(response, response->methodName.getString(), false, &body);
         STAT_SERVEREND  
   
    Array<Sint8> message = XmlWriter::formatSimpleMethodRspMessage(  
        response->methodName, response->messageId,  
        response->getHttpMethod(),  
           ((ContentLanguageListContainer)response->operationContext.get(ContentLanguageListContainer::NAME)).getLanguages(),  
        body, response->totServerTime,  
            response->isFirst(), response->isComplete());  
   
    STAT_BYTESSENT  
   
    sendResponse(response->queueIds.top(), message, response->isComplete(), response->getIndex());  
    PEG_METHOD_EXIT();  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.51  
changed lines
  Added in v.1.52
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2