Return to CIMOperationRequestDispatcher.cpp CVS log

Up to [Pegasus] / pegasus / src / WMIMapper / PegServer

BUG#: 6817
TITLE: WMI Mapper process the received requests sequentially.

DESCRIPTION: Requests to WMI Mapper are processed one by one. Thus, requests taking more time to complete may slow down the process and increase the pending requests queue causing timeout exceptions on client side.

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// 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
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//=============================================================================
//
// Author: Mike Brasher (mbrasher@bmc.com)
//
// Modified By:  Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
//               Chip Vincent (cvincent@us.ibm.com)
//               Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
//               Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
//               Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
//               Mike Day (mdday@us.ibm.com)
//               Carol Ann Krug Graves, Hewlett-Packard Company
//                   (carolann_graves@hp.com)
//               Barbara Packard, Hewlett-Packard Company
//                   (barbara_packard@hp.com)
//               Jair Santos, Hewlett-Packard Company (jair.santos@hp.com)
//               Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)
//               Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
//                 Seema Gupta (gseema@in.ibm.com) for PEP135
//
//%////////////////////////////////////////////////////////////////////////////

#include "CIMOperationRequestDispatcher.h"
#include <Pegasus/Common/Constants.h>
#include <Pegasus/Common/XmlReader.h> // stringToValue(), stringArrayToValue()
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Config/ConfigManager.h>
#include <Pegasus/Common/StatisticalData.h>

///////////////////////////////////////////////////////////////////////////////
// Need to include these before the WMI Provider headers
#include <atlbase.h>
#include <comdef.h>
#include <wbemcli.h>

///////////////////////////////////////////////////////////////////////////////
// WMI Provider interface headers
#include <WMIMapper/WMIProvider/WMIInstanceProvider.h>
#include <WMIMapper/WMIProvider/WMIClassProvider.h>
#include <WMIMapper/WMIProvider/WMIAssociatorProvider.h>
#include <WMIMapper/WMIProvider/WMIReferenceProvider.h>
#include <WMIMapper/WMIProvider/WMIQualifierProvider.h>
#include <WMIMapper/WMIProvider/WMIMethodProvider.h>
#include <WMIMapper/WMIProvider/WMIQueryProvider.h>

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

#ifndef TRC_WMI_MAPPER
#define TRC_WMI_MAPPER TRC_DISPATCHER
#endif

typedef struct threadParm
{
    Message* request;
    CIMOperationRequestDispatcher* dispatcher;
} ThreadParm_t;
CIMOperationRequestDispatcher::CIMOperationRequestDispatcher( )
//    CIMRepository* repository,
//    ProviderRegistrationManager* providerRegistrationManager)
      :
      Base(PEGASUS_QUEUENAME_OPREQDISPATCHER)
//      _repository(repository),
//      _providerRegistrationManager(providerRegistrationManager)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::CIMOperationRequestDispatcher");

    // Check whether or not AssociationTraversal is supported.
    //
    ConfigManager* configManager = ConfigManager::getInstance();
    _enableAssociationTraversal = ConfigManager::parseBooleanValue(
        configManager->getCurrentValue("enableAssociationTraversal"));
    //   _enableIndicationService = ConfigManager::parseBooleanValue(
    //        configManager->getCurrentValue("enableIndicationService"));

    PEG_METHOD_EXIT();
}

CIMOperationRequestDispatcher::~CIMOperationRequestDispatcher(void)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::~CIMOperationRequestDispatcher");
    _dying = 1;
    PEG_METHOD_EXIT();
}


void CIMOperationRequestDispatcher::_enqueueResponse(
   CIMRequestMessage* request,
   CIMResponseMessage* response)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_enqueueResponse");

    // Use the same key as used in the request:

    //response->setKey(request->getKey());
    response->dest = request->queueIds.top();

    if( true == Base::_enqueueResponse(request, response))
    {
        PEG_METHOD_EXIT();
        return;
    }

    MessageQueue * queue = MessageQueue::lookup(request->queueIds.top());
    PEGASUS_ASSERT(queue != 0 );

    queue->enqueue(response);

    PEG_METHOD_EXIT();
}

ThreadReturnType PEGASUS_THREAD_CDECL 
    CIMOperationRequestDispatcher::_callMethodHandler(void *parm)
{
    ThreadParm_t* myParms = reinterpret_cast<ThreadParm_t *>(parm);
    myParms->dispatcher->_handleOperationMessage(myParms->request);
    delete myParms;

    return 0;
}


void CIMOperationRequestDispatcher::_handleOperationMessage(Message *request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_handleOperationMessage("
        "Message *request)");

    if(!request)
    {
        PEG_METHOD_EXIT();
        return;
    }

    switch(request->getType())
    {

        case CIM_GET_CLASS_REQUEST_MESSAGE:
            handleGetClassRequest(
                (CIMGetClassRequestMessage*)request);
            break;

        case CIM_GET_INSTANCE_REQUEST_MESSAGE:
            handleGetInstanceRequest(
                (CIMGetInstanceRequestMessage*)request);
            break;

        case CIM_DELETE_CLASS_REQUEST_MESSAGE:
            handleDeleteClassRequest(
                (CIMDeleteClassRequestMessage*)request);
            break;

        case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
            handleDeleteInstanceRequest(
                (CIMDeleteInstanceRequestMessage*)request);
            break;

        case CIM_CREATE_CLASS_REQUEST_MESSAGE:
            handleCreateClassRequest(
                (CIMCreateClassRequestMessage*)request);
            break;

        case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
            handleCreateInstanceRequest(
                (CIMCreateInstanceRequestMessage*)request);
            break;

        case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
            handleModifyClassRequest(
                (CIMModifyClassRequestMessage*)request);
            break;

        case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
            handleModifyInstanceRequest(
                (CIMModifyInstanceRequestMessage*)request);
            break;

        case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
            handleEnumerateClassesRequest(
                (CIMEnumerateClassesRequestMessage*)request);
            break;

        case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
            handleEnumerateClassNamesRequest(
                (CIMEnumerateClassNamesRequestMessage*)request);
            break;

        case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
            handleEnumerateInstancesRequest(
                (CIMEnumerateInstancesRequestMessage*)request);
            break;

        case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
            handleEnumerateInstanceNamesRequest(
                (CIMEnumerateInstanceNamesRequestMessage*)request);
            break;

        case CIM_EXEC_QUERY_REQUEST_MESSAGE:
            handleExecQueryRequest(
                (CIMExecQueryRequestMessage*)request);
            break;

        case CIM_ASSOCIATORS_REQUEST_MESSAGE:
            handleAssociatorsRequest(
                (CIMAssociatorsRequestMessage*)request);
            break;

        case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
            handleAssociatorNamesRequest(
                (CIMAssociatorNamesRequestMessage*)request);
            break;

        case CIM_REFERENCES_REQUEST_MESSAGE:
            handleReferencesRequest(
                (CIMReferencesRequestMessage*)request);
            break;

        case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
            handleReferenceNamesRequest(
                (CIMReferenceNamesRequestMessage*)request);
            break;

        case CIM_GET_PROPERTY_REQUEST_MESSAGE:
            handleGetPropertyRequest(
                (CIMGetPropertyRequestMessage*)request);
            break;

        case CIM_SET_PROPERTY_REQUEST_MESSAGE:
            handleSetPropertyRequest(
                (CIMSetPropertyRequestMessage*)request);
            break;

        case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
            handleGetQualifierRequest(
                (CIMGetQualifierRequestMessage*)request);
            break;

        case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
            handleSetQualifierRequest(
                (CIMSetQualifierRequestMessage*)request);
            break;

        case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
            handleDeleteQualifierRequest(
                (CIMDeleteQualifierRequestMessage*)request);
            break;

        case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
            handleEnumerateQualifiersRequest(
                (CIMEnumerateQualifiersRequestMessage*)request);
            break;

        case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
            handleInvokeMethodRequest(
                (CIMInvokeMethodRequestMessage*)request);
            break;

        default:
            throw CIMException(CIM_ERR_NOT_SUPPORTED);
    }

    delete request;
    PEG_METHOD_EXIT();
}



// allocate a CIM Operation_async,  opnode, context, and response handler
// initialize with pointers to async top and async bottom
// link to the waiting q
void CIMOperationRequestDispatcher::handleEnqueue()
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_handleOperationMessage");

    Message* request = dequeue();

    if(request)
        handleEnqueue(request);

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnqueue(Message *request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnqueue(Message *request)");

    if(!request)
    {
        PEG_METHOD_EXIT();
        return;
    }

    ThreadParm_t* myParm = new ThreadParm_t;

    myParm->dispatcher = this;
    myParm->request = request;

    // allocate and run one thread for each request
    MessageQueueService::get_thread_pool()->allocate_and_awaken(
        myParm, 
        _callMethodHandler);

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleGetClassRequest(
   CIMGetClassRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleGetClassRequest");

    AutoPtr<CIMGetClassResponseMessage> response(
        dynamic_cast<CIMGetClassResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->cimClass = provider.getClass(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString(),
            request->localOnly,
            request->includeQualifiers,
            request->includeClassOrigin,
            request->propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "GetClass() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());
    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleGetInstanceRequest(
   CIMGetInstanceRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleGetInstanceRequest");

    AutoPtr<CIMGetInstanceResponseMessage> response(
        dynamic_cast<CIMGetInstanceResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    // get the class name
    String className = request->instanceName.getClassName().getString();

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->cimInstance = provider.getInstance(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->instanceName,
            request->localOnly,
            request->includeQualifiers,
            request->includeClassOrigin,
            request->propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "GetInstance() failed!");
    }

    // cancel the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());
    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleDeleteClassRequest(
   CIMDeleteClassRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleDeleteClassRequest");

    AutoPtr<CIMDeleteClassResponseMessage> response(
        dynamic_cast<CIMDeleteClassResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.deleteClass(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "DeleteClass() failed!");
    }
    
    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleDeleteInstanceRequest(
   CIMDeleteInstanceRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleDeleteInstanceRequest");

    AutoPtr<CIMDeleteInstanceResponseMessage> response(
        dynamic_cast<CIMDeleteInstanceResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.deleteInstance(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->instanceName);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "DeleteInstance() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleCreateClassRequest(
   CIMCreateClassRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleCreateClassRequest");

    AutoPtr<CIMCreateClassResponseMessage> response(
        dynamic_cast<CIMCreateClassResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.createClass(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->newClass);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "CreateClass() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleCreateInstanceRequest(
   CIMCreateInstanceRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleCreateInstanceRequest");

    AutoPtr<CIMCreateInstanceResponseMessage> response(
        dynamic_cast<CIMCreateInstanceResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->instanceName = provider.createInstance(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->newInstance);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "CreateInstance() failed!");
    }
    
    //terminate the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleModifyClassRequest(
   CIMModifyClassRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleModifyClassRequest");

    AutoPtr<CIMModifyClassResponseMessage> response(
        dynamic_cast<CIMModifyClassResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.modifyClass(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->modifiedClass);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            "modifyClass() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleModifyInstanceRequest(
   CIMModifyInstanceRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleModifyInstanceRequest");

    AutoPtr<CIMModifyInstanceResponseMessage> response(
        dynamic_cast<CIMModifyInstanceResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.modifyInstance(
           request->nameSpace.getString(),
          ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
           container.getPassword(),
           request->modifiedInstance,
           request->includeQualifiers,
           request->propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            "modifyInstance() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnumerateClassesRequest(
   CIMEnumerateClassesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnumerateClassesRequest");

    AutoPtr<CIMEnumerateClassesResponseMessage> response(
        dynamic_cast<CIMEnumerateClassesResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;
    
    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->cimClasses = provider.enumerateClasses(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString(),
            request->deepInheritance,
            request->localOnly,
            request->includeQualifiers,
            request->includeClassOrigin);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "enumerateClasses() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnumerateClassNamesRequest(
   CIMEnumerateClassNamesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnumerateClassNamesRequest");

    AutoPtr<CIMEnumerateClassNamesResponseMessage> response(
        dynamic_cast<CIMEnumerateClassNamesResponseMessage *>(
            request->buildResponse()));

    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->classNames = provider.enumerateClassNames(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString(),
            request->deepInheritance);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "enumerateClassNames() failed!");
    }

    //terminate the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnumerateInstancesRequest(
   CIMEnumerateInstancesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnumerateInstanceRequest");

    AutoPtr<CIMEnumerateInstancesResponseMessage> response(
        dynamic_cast<CIMEnumerateInstancesResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");
        CIMPropertyList propertyList(request->propertyList);

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize( );

        response->cimNamedInstances = provider.enumerateInstances(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString(),
            request->deepInheritance, request->localOnly, false, false,
            propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "enumerateInstances() failed!");
    }

    // cancel the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());
    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnumerateInstanceNamesRequest(
   CIMEnumerateInstanceNamesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnumerateInstanceNamesRequest");

    AutoPtr<CIMEnumerateInstanceNamesResponseMessage> response(
        dynamic_cast<CIMEnumerateInstanceNamesResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        // make the request...
        provider.initialize( );

        response->instanceNames = provider.enumerateInstanceNames(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->className.getString());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            "enumerateInstanceNames() failed!");
    }

    // cancel the provider
    provider.terminate();

    // and send the response
    _enqueueResponse(request, response.release());
    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleAssociatorsRequest(
   CIMAssociatorsRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleAssociatorsRequest");

    AutoPtr<CIMAssociatorsResponseMessage> response(
        dynamic_cast<CIMAssociatorsResponseMessage *>(
            request->buildResponse()));

    WMIAssociatorProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");
        CIMPropertyList propertyList(request->propertyList);

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize( );

        // ATTN: fix parameter list

        response->cimObjects = provider.associators(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->objectName,
            request->assocClass.getString(),
            request->resultClass.getString(),
            request->role,
            request->resultRole,
            request->includeQualifiers,
            request->includeClassOrigin,
            propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "associators() failed!");
    }
    
    // cancel the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleAssociatorNamesRequest(
   CIMAssociatorNamesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleAssociatorNamesRequest");

    AutoPtr<CIMAssociatorNamesResponseMessage> response(
        dynamic_cast<CIMAssociatorNamesResponseMessage *>(
            request->buildResponse()));

    WMIAssociatorProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize( );

        response->objectNames = provider.associatorNames(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->objectName,
            request->assocClass.getString(),
            request->resultClass.getString(),
            request->role,
            request->resultRole);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "associatorNames() failed!");
    }

    // cancel the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleReferencesRequest(
   CIMReferencesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleReferencesRequest");

    AutoPtr<CIMReferencesResponseMessage> response(
        dynamic_cast<CIMReferencesResponseMessage *>(
            request->buildResponse()));

    WMIReferenceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");
        CIMPropertyList propertyList(request->propertyList);

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize( );

        // ATTN: fix parameter list

        response->cimObjects = provider.references(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->objectName,
            request->resultClass.getString(),
            request->role,
            request->includeQualifiers,
            request->includeClassOrigin,
            propertyList);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "references() failed!");
    }
    
    // cancel the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleReferenceNamesRequest(
   CIMReferenceNamesRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleReferenceNamesRequest");

    AutoPtr<CIMReferenceNamesResponseMessage> response(
        dynamic_cast<CIMReferenceNamesResponseMessage *>(
            request->buildResponse()));

    WMIReferenceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize( );

        response->objectNames = provider.referenceNames(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->objectName,
            request->resultClass.getString(),
            request->role);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "referenceNames() failed!");
    }
    
    // cancel the provider
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleGetPropertyRequest(
   CIMGetPropertyRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleGetPropertyRequest");

    AutoPtr<CIMGetPropertyResponseMessage> response(
        dynamic_cast<CIMGetPropertyResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->value = provider.getProperty(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->instanceName,
            request->propertyName.getString());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "getProperty() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleSetPropertyRequest(
   CIMSetPropertyRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleSetPropertyRequest");

    AutoPtr<CIMSetPropertyResponseMessage> response(
        dynamic_cast<CIMSetPropertyResponseMessage *>(
            request->buildResponse()));

    WMIInstanceProvider provider;

    /* 
    {
        CIMException cimException;
        try
        {
            _fixSetPropertyValueType(request);
        }
        catch (CIMException& exception)
        {
            response->cimException = exception;
        }
        catch(Exception& exception)
        {
            response->cimException =
                PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
        }
        catch(...)
        {
            response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
                String::EMPTY);
        }

        if (cimException.getCode() != CIM_ERR_SUCCESS)
        {
            _enqueueResponse(request, response.release());

            PEG_METHOD_EXIT();
            return;
        }
    }
    */

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.setProperty(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->instanceName,
            request->propertyName.getString(),
            request->newValue);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "setProperty() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleGetQualifierRequest(
   CIMGetQualifierRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleGetQualifierRequest");

    AutoPtr<CIMGetQualifierResponseMessage> response(
        dynamic_cast<CIMGetQualifierResponseMessage *>(
            request->buildResponse()));

    WMIQualifierProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->cimQualifierDecl = provider.getQualifier(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->qualifierName.getString());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "getQualifier() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleSetQualifierRequest(
   CIMSetQualifierRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleSetQualifierRequest");

    AutoPtr<CIMSetQualifierResponseMessage> response(
        dynamic_cast<CIMSetQualifierResponseMessage *>(
            request->buildResponse()));

    WMIQualifierProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.setQualifier(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->qualifierDeclaration);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "setQualifier() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleDeleteQualifierRequest(
   CIMDeleteQualifierRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleDeleteQualifierRequest");

    AutoPtr<CIMDeleteQualifierResponseMessage> response(
        dynamic_cast<CIMDeleteQualifierResponseMessage *>(
            request->buildResponse()));

    WMIQualifierProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        provider.deleteQualifier(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->qualifierName.getString());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "deleteQualifier() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleEnumerateQualifiersRequest(
   CIMEnumerateQualifiersRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleEnumerateQualifiersRequest");

    AutoPtr<CIMEnumerateQualifiersResponseMessage> response(
        dynamic_cast<CIMEnumerateQualifiersResponseMessage *>(
            request->buildResponse()));

    WMIQualifierProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->qualifierDeclarations = provider.enumerateQualifiers(
            request->nameSpace.getString(),            
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword());
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "enumerateQualifiers() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleExecQueryRequest(
   CIMExecQueryRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleExecQueryRequest");

    AutoPtr<CIMExecQueryResponseMessage> response(
        dynamic_cast<CIMExecQueryResponseMessage *>(
            request->buildResponse()));

    WMIQueryProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->cimObjects = provider.execQuery(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->queryLanguage,
            request->query);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "execQuery() failed!");
    }

    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

void CIMOperationRequestDispatcher::handleInvokeMethodRequest(
   CIMInvokeMethodRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::handleInvokeMethodRequest");

    AutoPtr<CIMInvokeMethodResponseMessage> response(
        dynamic_cast<CIMInvokeMethodResponseMessage *>(
            request->buildResponse()));

    /*
    {
        try
        {
            _fixInvokeMethodParameterTypes(request);
        }
        catch(CIMException& exception)
        {
            response->cimException = exception;
        }
        catch(Exception& exception)
        {
            response->cimException =
                PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
        }
        catch(...)
        {
            response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
                String::EMPTY);
        }

        if (errorCode != CIM_ERR_SUCCESS)
        {
            _enqueueResponse(request, response.release());

            PEG_METHOD_EXIT();
            return;
        }
    }
    */

    WMIMethodProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");

        StatProviderTimeMeasurement providerTime(response.get());

        provider.initialize();

        response->retValue = provider.invokeMethod(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            request->instanceName,
            request->methodName.getString(),
            request->inParameters,
            response->outParameters);
    }
    catch(CIMException& exception)
    {
        response->cimException = exception;
    }
    catch(Exception& exception)
    {
        response->cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
            "invokeMethod() failed!");
    }

    // ATTN:  I need some exception handling here
    provider.terminate();

    // and send it
    _enqueueResponse(request, response.release());

    PEG_METHOD_EXIT();
}

/**
   Convert the specified CIMValue to the specified type, and return it in
   a new CIMValue.
*/
CIMValue CIMOperationRequestDispatcher::_convertValueType(
   const CIMValue& value,
   CIMType type)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_convertValueType");

    CIMValue newValue;

    if (value.isArray())
    {
        Array<String> stringArray;
        Array<char*> charPtrArray;
        Array<const char*> constCharPtrArray;

        //
        // Convert the value to Array<const char*> to send to conversion method
        //
        // ATTN-RK-P3-20020221: Deal with TypeMismatch exception
        // (Shouldn't really ever get that exception)
        value.get(stringArray);

        for (Uint32 k=0; k<stringArray.size(); k++)
        {
            // Need to build an Array<const char*> to send to the conversion
            // routine, but also need to keep track of them pointers as char*
            // because Windows won't let me delete a const char*.
            char* charPtr = strdup(stringArray[k].getCString());
            charPtrArray.append(charPtr);
            constCharPtrArray.append(charPtr);
        }

        //
        // Convert the value to the specified type
        //
        try
        {
            newValue = XmlReader::stringArrayToValue(0, 
                constCharPtrArray, type);
        }
        catch (XmlSemanticError&)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_PARAMETER,
            String("Malformed ") + cimTypeToString (type) + " value");
        }

        for (Uint32 k=0; k<charPtrArray.size(); k++)
        {
            delete charPtrArray[k];
        }
    }
    else
    {
        String stringValue;

        // ATTN-RK-P3-20020221: Deal with TypeMismatch exception
        // (Shouldn't really ever get that exception)
        value.get(stringValue);

        try
        {
            newValue = XmlReader::stringToValue(0, 
                stringValue.getCString(), type);
        }
        catch (XmlSemanticError&)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_PARAMETER,
            String("Malformed ") + cimTypeToString (type) + " value");
        }
    }

    PEG_METHOD_EXIT();
    return newValue;
}


/**
   Find the CIMParamValues in the InvokeMethod request whose types were
   not specified in the XML encoding, and convert them to the types
   specified in the method schema.
*/
void CIMOperationRequestDispatcher::_fixInvokeMethodParameterTypes(
   CIMInvokeMethodRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_fixInvokeMethodParameterTypes");

    Boolean gotMethodDefinition = false;
    CIMMethod method;

    //
    // Cycle through the input parameters, converting the untyped ones.
    //
    Array<CIMParamValue> inParameters = request->inParameters;
    Uint32 numInParamValues = inParameters.size();
    for (Uint32 i=0; i<numInParamValues; i++)
    {
        if (!inParameters[i].isTyped())
        {
            //
            // Retrieve the method definition, if we haven't already done so
            // (only look up the method if we have an untyped parameter value)
            //
            if (!gotMethodDefinition)
            {
                //
                // Get the class definition for this method
                //
                CIMClass cimClass;

                try
                {
                    WMIClassProvider provider;

                    provider.initialize();

                    WMIMapperUserInfoContainer container = 
                        request->operationContext.get
                        ("WMIMapperUserInfoContainer");

                    cimClass = provider.getClass(
                        request->nameSpace.getString(),
                        ((IdentityContainer) request->operationContext.get
                            (IdentityContainer::NAME)).getUserName(),
                        container.getPassword(),
                        request->instanceName.getClassName().getString(),
                        false, //localOnly,
                        false, //includeQualifiers,
                        false, //includeClassOrigin,
                        CIMPropertyList());
                }
                catch (CIMException&)
                {
                    PEG_METHOD_EXIT();
                    throw;
                }
                catch (Exception&)
                {
                    PEG_METHOD_EXIT();
                    throw;
                }
                catch (...)
                {
                    PEG_METHOD_EXIT();
                    throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_FOUND,
                                                String::EMPTY);
                }

                //
                // Get the method definition from the class
                //
                Uint32 methodPos = cimClass.findMethod(request->methodName);
                if (methodPos == PEG_NOT_FOUND)
                {
                    throw CIMException(CIM_ERR_METHOD_NOT_FOUND);
                }
                method = cimClass.getMethod(methodPos);

                gotMethodDefinition = true;
            }

            //
            // Find the parameter definition for this input parameter
            //
            CIMName paramName = inParameters[i].getParameterName();
            Uint32 numParams = method.getParameterCount();
            for (Uint32 j=0; j<numParams; j++)
            {
                CIMParameter param = method.getParameter(j);
                if (paramName == param.getName())
                {
                    //
                    // Retype the input parameter value according to the
                    // type defined in the class/method schema
                    //
                    CIMType paramType = param.getType();
                    CIMValue newValue;

                    if (inParameters[i].getValue().isNull())
                    {
                        newValue.setNullValue(param.getType(), 
                            param.isArray());
                    }
                    else if (inParameters[i].getValue().isArray() !=
                                 param.isArray())
                    {
                        // ATTN-RK-P1-20020222: Who catches this?  They aren't.
                        PEG_METHOD_EXIT();
                        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_TYPE_MISMATCH,
                                                    String::EMPTY);
                    }
                    else
                    {
                        newValue = _convertValueType(
                            inParameters[i].getValue(), paramType);
                    }

                    inParameters[i].setValue(newValue);
                    inParameters[i].setIsTyped(true);
                    break;
                }
            }
        }
    }

    PEG_METHOD_EXIT();
}

/**
   Convert the CIMValue given in a SetProperty request to the correct
   type according to the schema, because it is not possible to specify
   the property type in the XML encoding.
   Modified - bbp 08/15/02
*/

void CIMOperationRequestDispatcher::_fixSetPropertyValueType(
   CIMSetPropertyRequestMessage* request)
{
    PEG_METHOD_ENTER(TRC_WMI_MAPPER,
        "CIMOperationRequestDispatcher::_fixSetPropertyValueType");


    String sClassName;
    sClassName = (request->instanceName).getClassName().getString();

    String propertyName;
    propertyName = request->propertyName.getString();

    Array<CIMName> propertyNames;

    CIMName propName = propertyName;
    propertyNames.append(propName);

    CIMPropertyList propertyList = CIMPropertyList(propertyNames);    

    CIMValue inValue = request->newValue;

    //
    // Only do the conversion if the type is not already set
    //
    if ((inValue.getType() != CIMTYPE_STRING))
    {
        PEG_METHOD_EXIT();
        return;
    }

    //
    // Get the class definition for this property
    //
    CIMClass cimClass;
    CIMException cimException;
    WMIClassProvider provider;

    try
    {
        WMIMapperUserInfoContainer container = 
            request->operationContext.get("WMIMapperUserInfoContainer");
        
        provider.initialize();

        cimClass = provider.getClass(
            request->nameSpace.getString(),
            ((IdentityContainer) request->operationContext.get
                (IdentityContainer::NAME)).getUserName(),
            container.getPassword(),
            sClassName,
            false,
            false,
            false,
            propertyList);
    }
    catch(CIMException& exception)
    {
        cimException = exception;
    }
    catch(Exception& exception)
    {
        cimException =
            PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());
    }
    catch(...)
    {
        cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY);
    }

    //terminate the provider
    provider.terminate();

    //
    // Get the property definition from the class
    //
    Uint32 propertyPos = cimClass.findProperty(request->propertyName);
    if (propertyPos == PEG_NOT_FOUND)
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_TYPE_MISMATCH, String::EMPTY);
    }
    CIMProperty property = cimClass.getProperty(propertyPos);

    //
    // Retype the input property value according to the
    // type defined in the schema
    //
    CIMValue newValue;

    if (inValue.isNull())
    {
        newValue.setNullValue(property.getType(), property.isArray());
    }
    else if (inValue.isArray() != property.isArray())
    {
        // ATTN-RK-P1-20020222: Who catches this?  They aren't.
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_TYPE_MISMATCH, String::EMPTY);
    }
    else
    {
        newValue = _convertValueType(inValue, property.getType());
    }

    //
    // Put the retyped value back into the message
    //
    request->newValue = newValue;

    PEG_METHOD_EXIT();
}

PEGASUS_NAMESPACE_END