(file) Return to DefaultProviderManager.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Default

Diff for /pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp between version 1.18 and 1.96

version 1.18, 2004/02/27 05:59:17 version 1.96, 2014/08/27 23:10:11
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // 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.
 // //
 // 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: Chip Vincent (cvincent@us.ibm.com)  
 //  
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //              Mike Day, IBM (mdday@us.ibm.com)  
 //              Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.  
 //                      Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 33 
  
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
 #include <Pegasus/Common/OperationContext.h> #include <Pegasus/Common/OperationContext.h>
 #include <Pegasus/Common/Destroyer.h>  #include <Pegasus/Common/Time.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/MessageLoader.h> //l10n  #include <Pegasus/Common/MessageLoader.h>
   #include <Pegasus/Common/FileSystem.h>
   #include <Pegasus/Common/PegasusVersion.h>
   #include <Pegasus/Common/Constants.h>
  
 #include <Pegasus/Common/QueryExpression.h>  #include <Pegasus/Query/QueryExpression/QueryExpression.h>
 #include <Pegasus/ProviderManager2/QueryExpressionFactory.h> #include <Pegasus/ProviderManager2/QueryExpressionFactory.h>
  
 #include <Pegasus/Config/ConfigManager.h>  #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
   
 #include <Pegasus/ProviderManager2/Default/Provider.h>  
 #include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h>  
   
 #include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>  
 #include <Pegasus/ProviderManager2/ProviderManagerService.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // auto variable to protect provider during operations  
 class pm_service_op_lock  
 {  
 private:  
     pm_service_op_lock(void);  
   
 public:  
     pm_service_op_lock(Provider *provider) : _provider(provider)  
     {  
         _provider->protect();  
     }  
  
     ~pm_service_op_lock(void)  // A request class to hold the provider info passed to the
   // AsyncRequestExecutor for processing on different threads.
   class UnloadProviderRequest : public AsyncRequestExecutor::AsyncRequestMsg
     {     {
         _provider->unprotect();  public:
     }      UnloadProviderRequest(ProviderMessageHandler* provider)
           :_provider(provider) {}
  
     Provider * _provider;  public:
       ProviderMessageHandler* _provider;
 }; };
  
 // //
 // Provider module status  // Default Provider Manager
 // //
 static const Uint16 _MODULE_OK       = 2;  DefaultProviderManager::DefaultProviderManager()
 static const Uint16 _MODULE_STOPPING = 9;  {
 static const Uint16 _MODULE_STOPPED  = 10;      _subscriptionInitComplete = false;
   }
  
 // provider manager  DefaultProviderManager::~DefaultProviderManager()
 static LocalProviderManager providerManager;  {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::~DefaultProviderManager");
  
 DefaultProviderManager::DefaultProviderManager(void)      _shutdownAllProviders();
   
       for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
 { {
           ProviderMessageHandler* provider = i.value();
           delete provider;
 } }
  
 DefaultProviderManager::~DefaultProviderManager(void)      for (ModuleTable::Iterator j = _modules.start(); j != 0; j++)
 { {
           ProviderModule* module = j.value();
           delete module;
       }
   
       PEG_METHOD_EXIT();
 } }
  
 Message * DefaultProviderManager::processMessage(Message * request) throw()  Message* DefaultProviderManager::processMessage(Message* message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "DefaultProviderManager::processMessage()");         "DefaultProviderManager::processMessage()");
  
     Message * response = 0;      CIMRequestMessage* request = dynamic_cast<CIMRequestMessage*>(message);
       PEGASUS_ASSERT(request != 0);
   
       CIMResponseMessage* response = 0;
  
       try
       {
     // pass the request message to a handler method based on message type     // pass the request message to a handler method based on message type
     switch(request->getType())     switch(request->getType())
     {     {
     case CIM_GET_INSTANCE_REQUEST_MESSAGE:     case CIM_GET_INSTANCE_REQUEST_MESSAGE:
         response = handleGetInstanceRequest(request);  
   
         break;  
     case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:     case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
         response = handleEnumerateInstancesRequest(request);  
   
         break;  
     case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:     case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
         response = handleEnumerateInstanceNamesRequest(request);  
   
         break;  
     case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:     case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
         response = handleCreateInstanceRequest(request);  
   
         break;  
     case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:     case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
         response = handleModifyInstanceRequest(request);  
   
         break;  
     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
         response = handleDeleteInstanceRequest(request);  
   
         break;  
     case CIM_EXEC_QUERY_REQUEST_MESSAGE:     case CIM_EXEC_QUERY_REQUEST_MESSAGE:
         response = handleExecQueryRequest(request);  
   
         break;  
     case CIM_ASSOCIATORS_REQUEST_MESSAGE:     case CIM_ASSOCIATORS_REQUEST_MESSAGE:
         response = handleAssociatorsRequest(request);  
   
         break;  
     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
         response = handleAssociatorNamesRequest(request);  
   
         break;  
     case CIM_REFERENCES_REQUEST_MESSAGE:     case CIM_REFERENCES_REQUEST_MESSAGE:
         response = handleReferencesRequest(request);  
   
         break;  
     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
         response = handleReferenceNamesRequest(request);  
   
         break;  
     case CIM_GET_PROPERTY_REQUEST_MESSAGE:     case CIM_GET_PROPERTY_REQUEST_MESSAGE:
         response = handleGetPropertyRequest(request);  
   
         break;  
     case CIM_SET_PROPERTY_REQUEST_MESSAGE:     case CIM_SET_PROPERTY_REQUEST_MESSAGE:
         response = handleSetPropertyRequest(request);  
   
         break;  
     case CIM_INVOKE_METHOD_REQUEST_MESSAGE:     case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
         response = handleInvokeMethodRequest(request);  
   
         break;  
     case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:     case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
         response = handleCreateSubscriptionRequest(request);  
   
         break;  
     case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:     case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
         response = handleModifySubscriptionRequest(request);  
   
         break;  
     case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:     case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
         response = handleDeleteSubscriptionRequest(request);          case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
           {
               ProviderIdContainer providerId =
                   request->operationContext.get(ProviderIdContainer::NAME);
  
         break;              // resolve provider name
     case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:              ProviderName name = _resolveProviderName(providerId);
         response = handleEnableIndicationsRequest(request);  
  
         break;              // get cached or load new provider module
     case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:              ProviderOperationCounter poc(
         response = handleDisableIndicationsRequest(request);                  _getProvider(
                       name.getPhysicalName(),
                       name.getModuleName(),
                       name.getLogicalName()));
  
               response = poc.GetProvider().processMessage(request);
         break;         break;
     case CIM_CONSUME_INDICATION_REQUEST_MESSAGE:          }
         response = handleConsumeIndicationRequest(request);  
         break;  
  
     case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:          case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
         response = handleExportIndicationRequest(request);              response = _handleDisableModuleRequest(request);
         break;         break;
  
     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:          case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
         response = handleDisableModuleRequest(request);              response = _handleEnableModuleRequest(request);
               break;
  
           case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
               // tell the provider manager to shutdown all the providers
               _shutdownAllProviders();
               response = request->buildResponse();
         break;         break;
     case CIM_ENABLE_MODULE_REQUEST_MESSAGE:  
         response = handleEnableModuleRequest(request);  
  
           case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
               response = _handleSubscriptionInitCompleteRequest(request);
         break;         break;
     case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:  
         response = handleStopAllProvidersRequest(request);  
  
           case CIM_INDICATION_SERVICE_DISABLED_REQUEST_MESSAGE:
               response = _handleIndicationServiceDisabledRequest(request);
         break;         break;
     default:  
         response = handleUnsupportedRequest(request);  
  
           default:
               PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
         break;         break;
     }     }
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 } }
       catch (CIMException& e)
 Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw()      {
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s",
               (const char*)e.getMessage().getCString()));
           response = request->buildResponse();
           response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
               e.getContentLanguages(), e.getCode(), e.getMessage());
       }
       catch (Exception& e)
       {
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s",
               (const char*)e.getMessage().getCString()));
           response = request->buildResponse();
           response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
               e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage());
       }
       catch (...)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
               "Exception: Unknown");
           response = request->buildResponse();
           response->cimException = PEGASUS_CIM_EXCEPTION(
               CIM_ERR_FAILED, "Unknown error.");
       }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return response;
     // a null response implies unsupported or unknown operation  
     return(0);  
 } }
  
 Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw()  CIMResponseMessage* DefaultProviderManager::_handleDisableModuleRequest(
       CIMRequestMessage* message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_handleDisableModuleRequest");
     CIMGetInstanceRequestMessage * request =  
         dynamic_cast<CIMGetInstanceRequestMessage *>(const_cast<Message *>(message));  
  
       CIMDisableModuleRequestMessage* request =
           dynamic_cast<CIMDisableModuleRequestMessage*>(message);
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     CIMGetInstanceResponseMessage * response =      Array<Uint16> operationalStatus;
         new CIMGetInstanceResponseMessage(      CIMException cimException;
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         CIMInstance());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     // create a handler for this request  
     GetInstanceResponseHandler handler(request, response);  
  
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          // get provider module name
             "DefaultProviderManager::handleGetInstanceRequest - Host name: $0  Name space: $1  Class name: $2",          String moduleName;
             System::getHostName(),          CIMInstance mInstance = request->providerModule;
             request->nameSpace.getString(),          Uint32 pos = mInstance.findProperty(PEGASUS_PROPERTYNAME_NAME);
             request->instanceName.getClassName().getString());          PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
           mInstance.getProperty(pos).getValue().get(moduleName);
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->instanceName.getClassName(),  
             request->instanceName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMPropertyList propertyList(request->propertyList);  
   
         // forward request  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.getInstance: " +  
             ph.GetProvider().getName());  
  
         pm_service_op_lock op_lock(&ph.GetProvider());          //
           // Unload providers
           //
           Array<CIMInstance> providerInstances = request->providers;
  
         STAT_GETSTARTTIME;          for (Uint32 i = 0, n = providerInstances.size(); i < n; i++)
           {
               String pName;
               providerInstances[i].getProperty(
                   providerInstances[i].findProperty(PEGASUS_PROPERTYNAME_NAME)).
                       getValue().get(pName);
  
         ph.GetProvider().getInstance(              Sint16 ret_value = _disableProvider(moduleName, pName);
             context,  
             objectPath,  
             request->includeQualifiers,  
             request->includeClassOrigin,  
             propertyList,  
             handler);  
  
         STAT_PMS_PROVIDEREND;              if (ret_value == 0)
               {
                   // disable failed since there are pending requests,
                   // stop trying to disable other providers in this module.
                   operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
                   break;
               }
               else if (ret_value != 1)  // Not success
               {
                   // disable failed for other reason, throw exception
                   throw PEGASUS_CIM_EXCEPTION_L(
                       CIM_ERR_FAILED,
                       MessageLoaderParms(
                           "ProviderManager.ProviderManagerService."
                               "DISABLE_PROVIDER_FAILED",
                           "Failed to disable the provider."));
               }
           }
     }     }
     catch(CIMException & e)     catch(CIMException & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s",
             "Exception: " + e.getMessage());              (const char*)e.getMessage().getCString()));
           cimException = e;
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s",
             "Exception: " + e.getMessage());              (const char*)e.getMessage().getCString()));
           cimException = CIMException(CIM_ERR_FAILED, e.getMessage());
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception: Unknown");             "Exception: Unknown");
           cimException = PEGASUS_CIM_EXCEPTION_L(
               CIM_ERR_FAILED,
               MessageLoaderParms(
                   "ProviderManager.ProviderManagerService.UNKNOWN_ERROR",
                   "Unknown Error"));
       }
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");      if (cimException.getCode() == CIM_ERR_SUCCESS)
       {
           // Status is set to OK if a provider was busy
           if (operationalStatus.size() == 0)
           {
               operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
     }     }
       }
       else
       {
           // If exception occurs, module is not stopped
           operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
       }
   
       CIMDisableModuleResponseMessage* response =
           dynamic_cast<CIMDisableModuleResponseMessage*>(
               request->buildResponse());
       PEGASUS_ASSERT(response != 0);
   
       response->operationalStatus = operationalStatus;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  
     return(response);      return response;
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()  CIMResponseMessage* DefaultProviderManager::_handleEnableModuleRequest(
       CIMRequestMessage* message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_handleEnableModuleRequest");
     CIMEnumerateInstancesRequestMessage * request =  
         dynamic_cast<CIMEnumerateInstancesRequestMessage *>(const_cast<Message *>(message));  
  
       CIMEnableModuleRequestMessage* request =
           dynamic_cast<CIMEnableModuleRequestMessage*>(message);
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     CIMEnumerateInstancesResponseMessage * response =      Array<Uint16> operationalStatus;
         new CIMEnumerateInstancesResponseMessage(      operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMInstance>());  
  
       CIMEnableModuleResponseMessage* response =
           dynamic_cast<CIMEnableModuleResponseMessage*>(
               request->buildResponse());
     PEGASUS_ASSERT(response != 0);     PEGASUS_ASSERT(response != 0);
  
     // preserve message key      response->operationalStatus = operationalStatus;
     response->setKey(request->getKey());  
  
     //  Set HTTP method in response from request      PEG_METHOD_EXIT();
     response->setHttpMethod (request->getHttpMethod ());      return response;
   }
  
     // create a handler for this request  
     EnumerateInstancesResponseHandler handler(request, response);  
  
     try  CIMResponseMessage*
   DefaultProviderManager::_handleIndicationServiceDisabledRequest(
       CIMRequestMessage* message)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
             "DefaultProviderManager::handleEnumerateInstancesRequest - Host name: $0  Name space: $1  Class name: $2",          "DefaultProviderManager::_handleIndicationServiceDisabledRequest");
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->className.getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->className);  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),  
                 name.getLogicalName(), String::EMPTY);  
  
         // convert arguments      CIMIndicationServiceDisabledRequestMessage* request =
         OperationContext context;          dynamic_cast<CIMIndicationServiceDisabledRequestMessage*>(message);
       PEGASUS_ASSERT(request != 0);
  
         context.insert(IdentityContainer(request->userName));      CIMIndicationServiceDisabledResponseMessage* response =
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));          dynamic_cast<CIMIndicationServiceDisabledResponseMessage*>(
         context.insert(ContentLanguageListContainer(request->contentLanguages));              request->buildResponse());
       PEGASUS_ASSERT(response != 0);
  
         CIMPropertyList propertyList(request->propertyList);      _subscriptionInitComplete = false;
  
         // forward request      // Make a copy of the table so it is not locked during the provider calls
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      Array<ProviderMessageHandler*> providerList;
             "Calling provider.enumerateInstances: " +      {
             ph.GetProvider().getName());          AutoMutex lock(_providerTableMutex);
  
         pm_service_op_lock op_lock(&ph.GetProvider());          for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
           {
               providerList.append(i.value());
           }
       }
  
         STAT_GETSTARTTIME;      //
       // Notify all providers that indication service is disabled
       //
       for (Uint32 j = 0; j < providerList.size(); j++)
       {
           AutoMutex lock(providerList[j]->status.getStatusMutex());
  
         ph.GetProvider().enumerateInstances(          if (providerList[j]->status.isInitialized())
             context,          {
             objectPath,              providerList[j]->indicationServiceDisabled();
             request->includeQualifiers,          }
             request->includeClassOrigin,      }
             propertyList,  
             handler);  
  
         STAT_PMS_PROVIDEREND;      PEG_METHOD_EXIT();
       return response;
     }     }
     catch(CIMException & e)  
   CIMResponseMessage*
   DefaultProviderManager::_handleSubscriptionInitCompleteRequest(
       CIMRequestMessage* message)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
             "Exception: " + e.getMessage());          "DefaultProviderManager::_handleSubscriptionInitCompleteRequest");
  
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n      CIMSubscriptionInitCompleteRequestMessage* request =
     }          dynamic_cast<CIMSubscriptionInitCompleteRequestMessage*>(message);
     catch(Exception & e)      PEGASUS_ASSERT(request != 0);
   
       CIMSubscriptionInitCompleteResponseMessage* response =
           dynamic_cast<CIMSubscriptionInitCompleteResponseMessage*>(
               request->buildResponse());
       PEGASUS_ASSERT(response != 0);
   
       _subscriptionInitComplete = true;
   
       // Make a copy of the table so it is not locked during the provider calls
       Array<ProviderMessageHandler*> providerList;
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          AutoMutex lock(_providerTableMutex);
             "Exception: " + e.getMessage());  
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n          for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
           {
               providerList.append(i.value());
     }     }
     catch(...)      }
   
       //
       // Notify all providers that subscription initialization is complete
       //
       for (Uint32 j = 0; j < providerList.size(); j++)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          AutoMutex lock(providerList[j]->status.getStatusMutex());
             "Exception: Unknown");  
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          if (providerList[j]->status.isInitialized())
           {
               providerList[j]->subscriptionInitComplete();
           }
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return response;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()  ProviderName DefaultProviderManager::_resolveProviderName(
       const ProviderIdContainer& providerId)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");      String providerName;
       String fileName;
     CIMEnumerateInstanceNamesRequestMessage * request =      String moduleName;
         dynamic_cast<CIMEnumerateInstanceNamesRequestMessage *>(const_cast<Message *>(message));      CIMValue genericValue;
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMEnumerateInstanceNamesResponseMessage * response =  
         new CIMEnumerateInstanceNamesResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObjectPath>());  
  
     PEGASUS_ASSERT(response != 0);      genericValue = providerId.getModule().getProperty(
           providerId.getModule().findProperty(
               PEGASUS_PROPERTYNAME_NAME)).getValue();
       genericValue.get(moduleName);
  
     // preserve message key      genericValue = providerId.getProvider().getProperty(
     response->setKey(request->getKey());          providerId.getProvider().findProperty(
               PEGASUS_PROPERTYNAME_NAME)).getValue();
       genericValue.get(providerName);
  
     //set HTTP method in response from request      genericValue = providerId.getModule().getProperty(
     response->setHttpMethod(request->getHttpMethod());;          providerId.getModule().findProperty("Location")).getValue();
       genericValue.get(fileName);
  
     // create a handler for this request      String resolvedFileName = _resolvePhysicalName(fileName);
     EnumerateInstanceNamesResponseHandler handler(request, response);  
  
     // process the request      if (resolvedFileName == String::EMPTY)
     try  
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          // Provider library not found
             "DefaultProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0  Name space: $1  Class name: $2",          throw Exception(MessageLoaderParms(
             System::getHostName(),              "ProviderManager.ProviderManagerService.PROVIDER_FILE_NOT_FOUND",
             request->nameSpace.getString(),              "File \"$0\" was not found for provider module \"$1\".",
             request->className.getString());              FileSystem::buildLibraryFileName(fileName), moduleName));
       }
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->className);  
   
         // build an internal provider name from the request arguments  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
  
         // resolve provider name      return ProviderName(moduleName, providerName, resolvedFileName);
         name = _resolveProviderName(name);  }
  
         // get cached or load new provider module  ProviderOperationCounter DefaultProviderManager::_getProvider(
         OpProviderHolder ph =      const String& moduleFileName,
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());      const String& moduleName,
       const String& providerName)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_getProvider");
  
         // convert arguments      ProviderMessageHandler* pr = _lookupProvider(moduleName, providerName);
         OperationContext context;  
  
         context.insert(IdentityContainer(request->userName));      if (!pr->status.isInitialized())
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));      {
         context.insert(ContentLanguageListContainer(request->contentLanguages));          _initProvider(pr, moduleFileName);
       }
  
         // forward request      AutoMutex lock(pr->status.getStatusMutex());
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.enumerateInstanceNames: " +  
             ph.GetProvider().getName());  
  
         pm_service_op_lock op_lock(&ph.GetProvider());      if (!pr->status.isInitialized())
       {
           PEG_METHOD_EXIT();
           throw PEGASUS_CIM_EXCEPTION(
               CIM_ERR_FAILED, "provider initialization failed");
       }
  
         STAT_GETSTARTTIME;      ProviderOperationCounter poc(pr);
  
         ph.GetProvider().enumerateInstanceNames(      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Returning Provider %s",
             context,          (const char*)providerName.getCString()));
             objectPath,  
             handler);  
  
         STAT_PMS_PROVIDEREND;      PEG_METHOD_EXIT();
       return poc;
     }     }
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  ProviderMessageHandler* DefaultProviderManager::_lookupProvider(
     }      const String& moduleName,
     catch(Exception & e)      const String& providerName)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
             "Exception: " + e.getMessage());          "DefaultProviderManager::_lookupProvider");
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n      // lock the providerTable mutex
       AutoMutex lock(_providerTableMutex);
   
       // Construct the lookup key. We need a compound key to differentiate
       // providers with the same name from different modules. The size field is
       // added to handle the unlikely case when moduleName+providerName
       // produce identical strings but define different providers.
       char buffer[12];
       sprintf(buffer, "%u:", providerName.size());
       const String key = buffer + moduleName + ":" + providerName;
   
       // look up provider in cache
       ProviderMessageHandler* pr = 0;
       if (_providers.lookup(key, pr))
       {
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Found Provider %s in Provider Manager Cache",
               (const char*)providerName.getCString()));
     }     }
     catch(...)      else
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          // create provider
             "Exception: Unknown");          pr = new ProviderMessageHandler(
               moduleName, providerName,
               0, _indicationCallback, _responseChunkCallback,
               _subscriptionInitComplete);
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          // insert provider in provider table
           _providers.insert(key, pr);
   
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Created provider %s",
               (const char*)pr->getName().getCString()));
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return pr;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw()  ProviderMessageHandler* DefaultProviderManager::_initProvider(
       ProviderMessageHandler* provider,
       const String& moduleFileName)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_initProvider");
     CIMCreateInstanceRequestMessage * request =  
         dynamic_cast<CIMCreateInstanceRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
  
     // create response message      ProviderModule* module = 0;
     CIMCreateInstanceResponseMessage * response =      CIMProvider* base;
         new CIMCreateInstanceResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         CIMObjectPath());  
  
     PEGASUS_ASSERT(response != 0);      // lookup provider module
       module = _lookupModule(moduleFileName);
  
     // preserve message key      // lock the provider status mutex
     response->setKey(request->getKey());      AutoMutex lock(provider->status.getStatusMutex());
  
     //  Set HTTP method in response from request      if (provider->status.isInitialized())
     response->setHttpMethod (request->getHttpMethod ());      {
           // Initialization is already complete
           return provider;
       }
  
     // create a handler for this request      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
     CreateInstanceResponseHandler handler(request, response);          "Loading/Linking Provider Module %s",
           (const char*)moduleFileName.getCString()));
  
       // load the provider
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          base = module->load(provider->getName());
             "DefaultProviderManager::handleCreateInstanceRequest - Host name: $0  Name space: $1  Class name: $2",      }
             System::getHostName(),      catch (...)
             request->nameSpace.getString(),      {
             request->newInstance.getPath().getClassName().getString());          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
               "Exception caught Loading/Linking Provider Module %s",
         // make target object path              (const char*)moduleFileName.getCString()));
         CIMObjectPath objectPath(          PEG_METHOD_EXIT();
             System::getHostName(),          throw;
             request->nameSpace,      }
             request->newInstance.getPath().getClassName(),  
             request->newInstance.getPath().getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
  
         // resolve provider name      // initialize the provider
         name = _resolveProviderName(name);      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, "Initializing Provider %s",
           (const char*)provider->getName().getCString()));
  
         // get cached or load new provider module      CIMOMHandle* cimomHandle = new CIMOMHandle();
         OpProviderHolder ph =      provider->status.setCIMOMHandle(cimomHandle);
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);      provider->status.setModule(module);
       provider->setProvider(base);
  
         // convert arguments      Boolean initializeError = false;
         OperationContext context;  
  
         context.insert(IdentityContainer(request->userName));      try
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));      {
         context.insert(ContentLanguageListContainer(request->contentLanguages));          provider->initialize(*cimomHandle);
       }
       catch (...)
       {
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
               "Initialization Error.  Provider %s",
               (const char*)provider->getName().getCString()));
           initializeError = true;
       }
  
         // forward request      // The cleanup code executed when an exception occurs was previously
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      // included in the catch block above. Unloading the provider module
             "Calling provider.createInstance: " +      // from inside the catch block resulted in a crash when an exception
             ph.GetProvider().getName());      // was thrown from a provider's initialize() method. The issue is that
       // when an exception is thrown, the program maintains internal
       // pointers related to the code that threw the exception. In the case
       // of an exception thrown from a provider during the initialize()
       // method, those pointers point into the provider library, so when
       // the DefaultProviderManager unloads the library, the pointers into
       // the library that the program was holding are invalid.
  
         pm_service_op_lock op_lock(&ph.GetProvider());      if (initializeError == true)
       {
           // Allow the provider to clean up
           provider->terminate();
  
         STAT_GETSTARTTIME;          // delete the cimom handle
           delete cimomHandle;
  
         ph.GetProvider().createInstance(          provider->setProvider(0);
             context,  
             objectPath,  
             request->newInstance,  
             handler);  
  
         STAT_PMS_PROVIDEREND;          // unload provider module
           module->unloadModule();
     }     }
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n      provider->status.setInitialized(!initializeError);
   
       PEG_METHOD_EXIT();
       return provider;
     }     }
     catch(Exception & e)  
   ProviderModule* DefaultProviderManager::_lookupModule(
       const String& moduleFileName)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
             "Exception: " + e.getMessage());          "DefaultProviderManager::_lookupModule");
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n      // lock the providerTable mutex
       AutoMutex lock(_providerTableMutex);
   
       // look up provider module in cache
       ProviderModule* module = 0;
   
       if (_modules.lookup(moduleFileName, module))
       {
           // found provider module in cache
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Found Provider Module %s in Provider Manager Cache",
               (const char*)moduleFileName.getCString()));
     }     }
     catch(...)      else
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          // provider module not found in cache, create provider module
             "Exception: Unknown");          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Creating Provider Module %s",
               (const char*)moduleFileName.getCString()));
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          module = new ProviderModule(moduleFileName);
   
           // insert provider module in module table
           _modules.insert(moduleFileName, module);
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return module;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw()  Boolean DefaultProviderManager::hasActiveProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::hasActiveProviders");
     CIMModifyInstanceRequestMessage * request =  
         dynamic_cast<CIMModifyInstanceRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     // create response message  
     CIMModifyInstanceResponseMessage * response =  
         new CIMModifyInstanceResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     // create a handler for this request  
     ModifyInstanceResponseHandler handler(request, response);  
  
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          AutoMutex lock(_providerTableMutex);
             "DefaultProviderManager::handleModifyInstanceRequest - Host name: $0  Name space: $1  Class name: $2",          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             System::getHostName(),              "Number of providers in _providers table = %d", _providers.size()));
             request->nameSpace.getString(),  
             request->modifiedInstance.getPath().getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->modifiedInstance.getPath ().getClassName(),  
             request->modifiedInstance.getPath ().getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
  
         CIMPropertyList propertyList(request->propertyList);          // Iterate through the _providers table looking for an active provider
           for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
         // forward request  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.modifyInstance: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         STAT_GETSTARTTIME;  
   
         ph.GetProvider().modifyInstance(  
             context,  
             objectPath,  
             request->modifiedInstance,  
             request->includeQualifiers,  
             propertyList,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              if (i.value()->status.isInitialized())
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                  PEG_METHOD_EXIT();
             "Exception: " + e.getMessage());                  return true;
               }
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n          }
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          // Unexpected exception; do not assume that no providers are loaded
             "Exception: Unknown");          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
               "Unexpected Exception in hasActiveProviders.");
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          PEG_METHOD_EXIT();
           return true;
     }     }
  
       // No active providers were found in the _providers table
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return false;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw()  void DefaultProviderManager::unloadIdleProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::unloadIdleProviders");
     CIMDeleteInstanceRequestMessage * request =  
         dynamic_cast<CIMDeleteInstanceRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     // create response message  
     CIMDeleteInstanceResponseMessage * response =  
         new CIMDeleteInstanceResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     // create a handler for this request  
     DeleteInstanceResponseHandler handler(request, response);  
  
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          struct timeval now;
             "DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0  Name space: $1  Class name: $2",          Time::gettimeofday(&now);
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->instanceName.getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->instanceName.getClassName(),  
             request->instanceName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         // forward request  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.deleteInstance: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         STAT_GETSTARTTIME;  
   
         ph.GetProvider().deleteInstance(  
             context,  
             objectPath,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n          // Make a copy of the table so it is not locked during provider calls
     }          Array<ProviderMessageHandler*> providerList;
     catch(Exception & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              AutoMutex lock(_providerTableMutex);
             "Exception: " + e.getMessage());  
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n              for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
     }  
     catch(...)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                  providerList.append(i.value());
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  
     }     }
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) throw()          for (Uint32 i = 0; i < providerList.size(); i++)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");              ProviderMessageHandler* provider = providerList[i];
   
     CIMExecQueryRequestMessage * request =  
         dynamic_cast<CIMExecQueryRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMExecQueryResponseMessage * response =  
         new CIMExecQueryResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObject>());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
  
     //  Set HTTP method in response from request              AutoMutex lock(provider->status.getStatusMutex());
     response->setHttpMethod (request->getHttpMethod ());  
  
     // create a handler for this request              if (!provider->status.isInitialized())
     ExecQueryResponseHandler handler(request, response);  
   
     try  
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,                  continue;
             "DefaultProviderManager::handleExecQueryRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->className.getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->className);  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::QUERY);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(),  
                                         name.getLogicalName(), String::EMPTY);  
   
         if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) {  
            String errorString = " instance provider is registered supporting execQuery "  
                                 "but is not a CIMQueryInstanceProvider subclass.";  
            throw CIMException(CIM_ERR_FAILED,"ProviderLoadFailure (" + name.getPhysicalName() + ":" +  
                             name.getLogicalName() + "):" + errorString);  
         }         }
  
         // convert arguments              struct timeval providerTime = {0, 0};
         OperationContext context;              provider->status.getLastOperationEndTime(&providerTime);
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         QueryExpression qx(QueryExpressionFactory::routeBuildQueryExpressionRep  
            (request->queryLanguage,request->query));  
   
         // forward request  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.executeQueryRequest: " +  
             ph.GetProvider().getName());  
  
         pm_service_op_lock op_lock(&ph.GetProvider());              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                   "provider->status.isIdle() returns: %s",
                   (const char*)CIMValue(provider->status.isIdle())
                          .toString().getCString()));
  
         STAT_GETSTARTTIME;              if (provider->status.isIdle() &&
                   ((now.tv_sec - providerTime.tv_sec) >
         ph.GetProvider().execQuery(                   ((Sint32)PEGASUS_PROVIDER_IDLE_TIMEOUT_SECONDS)))
             context,  
             objectPath,  
             qx,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,                  PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
             "Exception: " + e.getMessage());                      "Unloading idle provider: %s",
                       (const char*)provider->getName().getCString()));
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n                  _unloadProvider(provider);
               }
     }     }
     catch(Exception & e)  
     {  
            cout<<"--- exception not a CIMInstanceQueryProvider"<<endl;  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception: Unknown");              "Caught unexpected exception in unloadIdleProviders.");
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
   
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw()  void DefaultProviderManager::_shutdownAllProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_shutdownAllProviders");
     CIMAssociatorsRequestMessage * request =  
         dynamic_cast<CIMAssociatorsRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMAssociatorsResponseMessage * response =  
         new CIMAssociatorsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObject>());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
  
     // create a handler for this request      AutoMutex lock(_providerTableMutex);
     AssociatorsResponseHandler handler(request, response);      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
           "providers in cache = %d", _providers.size()));
  
     // process the request      //create an array of UnloadProviderRequest requests one per
     try      //provider to process shutdown of providers simultaneously.
       Array<AsyncRequestExecutor::AsyncRequestMsg*> ProviderRequests;
       for (ProviderTable::Iterator i = _providers.start(); i != 0; i++)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          AutoMutex lock(i.value()->status.getStatusMutex());
             "DefaultProviderManager::handleAssociatorsRequest - Host name: $0  Name space: $1  Class name: $2",          if(i.value()->status.isInitialized())
             System::getHostName(),          {
             request->nameSpace.getString(),              ProviderRequests.append(
             request->objectName.getClassName().getString());                  new UnloadProviderRequest(i.value()));
           }
         // make target object path      }
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->objectName.getClassName());  
   
         objectPath.setKeyBindings(request->objectName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
  
         // convert arguments      //run the stop request on all providers on multiple threads using
         OperationContext context;      //the request executor. This will invoke _asyncRequestCallback() on a
       //seperate thread for each provider which in turn will unload that
       //provider.
  
         context.insert(IdentityContainer(request->userName));      CIMException exception =
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));          AsyncRequestExecutor(&_asyncRequestCallback,this).executeRequests(
         context.insert(ContentLanguageListContainer(request->contentLanguages));              ProviderRequests);
   
         // ATTN KS STAT_GETSTARTTIME;  
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().associators(  
             context,  
             objectPath,  
             request->assocClass,  
             request->resultClass,  
             request->role,  
             request->resultRole,  
             request->includeQualifiers,  
             request->includeClassOrigin,  
             request->propertyList.getPropertyNameArray(),  
             handler);  
  
         STAT_PMS_PROVIDEREND;      if(exception.getCode() != CIM_ERR_SUCCESS)
     }  
     catch(CIMException & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Exception: " + e.getMessage());              "Unexpected Exception in _shutdownAllProviders().");
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n      PEG_METHOD_EXIT();
     }     }
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  Sint16 DefaultProviderManager::_disableProvider(
     }      const String& moduleName,
       const String& providerName)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_disableProvider");
  
       ProviderMessageHandler* pr = _lookupProvider(moduleName, providerName);
       if (!pr->status.isInitialized())
       {
           PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
               "Provider %s is not loaded",
               (const char*)providerName.getCString()));
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
           return 1;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message) throw()      PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Disable Provider %s",
           (const char*)pr->getName().getCString()));
       //
       // Check to see if there are pending requests. If there are pending
       // requests and the disable timeout has not expired, loop and wait one
       // second until either there is no pending requests or until timeout
       // expires.
       //
       Uint32 waitTime = PROVIDER_DISABLE_TIMEOUT;
       while ((pr->status.numCurrentOperations() > 0) && (waitTime > 0))
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");          Threads::sleep(1000);
           waitTime = waitTime - 1;
     CIMAssociatorNamesRequestMessage * request =      }
         dynamic_cast<CIMAssociatorNamesRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMAssociatorNamesResponseMessage * response =  
         new CIMAssociatorNamesResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObjectPath>());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
  
     // create a handler for this request      // There are still pending requests, do not disable
     AssociatorNamesResponseHandler handler(request, response);      if (pr->status.numCurrentOperations() > 0)
       {
           PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Disable failed since there are pending requests.");
           PEG_METHOD_EXIT();
           return 0;
       }
  
     // process the request  
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          AutoMutex lock(pr->status.getStatusMutex());
             "DefaultProviderManager::handleAssociationNamesRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->objectName.getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->objectName.getClassName());  
   
         objectPath.setKeyBindings(request->objectName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
  
         // convert arguments          if (pr->status.isInitialized())
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().associatorNames(  
             context,  
             objectPath,  
             request->assocClass,  
             request->resultClass,  
             request->role,  
             request->resultRole,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());                  "Unloading Provider %s",
                   (const char*)pr->getName().getCString()));
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n              _unloadProvider(pr);
     }     }
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
             "Exception: Unknown");              "Unload provider failed %s",
               (const char*)pr->getName().getCString()));
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          PEG_METHOD_EXIT();
           return -1;
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return 1;
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw()  void DefaultProviderManager::_unloadProvider(ProviderMessageHandler* provider)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");      //
       // NOTE:  It is the caller's responsibility to make sure that the
     CIMReferencesRequestMessage * request =      // provider->status.getStatusMutex() mutex is locked before calling
         dynamic_cast<CIMReferencesRequestMessage *>(const_cast<Message *>(message));      // this method.
       //
     PEGASUS_ASSERT(request != 0);  
   
     CIMReferencesResponseMessage * response =  
         new CIMReferencesResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObject>());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
  
     // create a handler for this request      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
     ReferencesResponseHandler handler(request, response);          "DefaultProviderManager::_unloadProvider");
  
     // process the request      if (provider->status.numCurrentOperations() > 0)
     try  
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "DefaultProviderManager::handleReferencesRequest - Host name: $0  Name space: $1  Class name: $2",              "Provider cannot be unloaded due to pending operations: %s",
             System::getHostName(),              (const char*)provider->getName().getCString()));
             request->nameSpace.getString(),      }
             request->objectName.getClassName().getString());      else
       {
         // make target object path          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
         CIMObjectPath objectPath(              "Terminating Provider %s",
             System::getHostName(),              (const char*)provider->getName().getCString()));
             request->nameSpace,  
             request->objectName.getClassName());  
   
         objectPath.setKeyBindings(request->objectName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
  
         // convert arguments          provider->terminate();
         OperationContext context;  
  
         context.insert(IdentityContainer(request->userName));          // unload provider module
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));          PEGASUS_ASSERT(provider->status.getModule() != 0);
         context.insert(ContentLanguageListContainer(request->contentLanguages));          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
               "Unloading provider module: %s",
         STAT_GETSTARTTIME;              (const char*)provider->getName().getCString()));
           provider->status.getModule()->unloadModule();
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.references: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().references(  
             context,  
             objectPath,  
             request->resultClass,  
             request->role,  
             request->includeQualifiers,  
             request->includeClassOrigin,  
             request->propertyList.getPropertyNameArray(),  
             handler);  
  
         STAT_PMS_PROVIDEREND;          PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
     }              "DefaultProviderManager: Unloaded provider %s",
     catch(CIMException & e)              (const char*)provider->getName().getCString()));
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n          // NOTE: The "delete provider->status.getCIMOMHandle()" operation
     }          //   was moved to be called after the unloadModule() call above
     catch(Exception & e)          //   as part of a fix for bugzilla 3669. For some providers
     {          //   run out-of-process on Windows platforms (i.e. running
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          //   the cimserver with the forceProviderProcesses config option
             "Exception: " + e.getMessage());          //   set to "true"), deleting the provider's CIMOMHandle before
           //   unloading the provider library caused the unload mechanism
           //   to deadlock, making that provider unavailable and preventing
           //   the cimserver from shutting down. It should NOT be moved back
           //   above the unloadModule() call. See bugzilla 3669 for details.
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n          // delete the cimom handle
     }          PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
     catch(...)              "Destroying provider's CIMOMHandle: %s",
     {              (const char*)provider->getName().getCString()));
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          delete provider->status.getCIMOMHandle();
             "Exception: Unknown");  
  
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");          // set provider status to uninitialized
           provider->status.setInitialized(false);
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
   
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw()  ProviderManager* DefaultProviderManager::createDefaultProviderManagerCallback()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");      return new DefaultProviderManager();
   }
     CIMReferenceNamesRequestMessage * request =  
         dynamic_cast<CIMReferenceNamesRequestMessage *>(const_cast<Message *>(message));  
  
     PEGASUS_ASSERT(request != 0);  //async request handler method invoked on a seperate thread per provider
   //through the async request executor.
   CIMException DefaultProviderManager::_asyncRequestCallback(
       void *callbackPtr,
       AsyncRequestExecutor::AsyncRequestMsg* request)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_asyncRequestCallback");
  
     CIMReferenceNamesResponseMessage * response =      CIMException responseException;
         new CIMReferenceNamesResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         Array<CIMObjectPath>());  
   
     // preserve message key  
     response->setKey(request->getKey());  
  
     //  Set HTTP method in response from request      //extract the parameters
     response->setHttpMethod (request->getHttpMethod ());      UnloadProviderRequest* my_request =
           dynamic_cast<UnloadProviderRequest*>(request);
       if(my_request != NULL)
       {
           PEGASUS_ASSERT(0 != callbackPtr);
  
     // create a handler for this request          DefaultProviderManager *dpmPtr =
     ReferenceNamesResponseHandler handler(request, response);              static_cast<DefaultProviderManager*>(callbackPtr);
  
     // process the request          ProviderMessageHandler* provider =
               dynamic_cast<ProviderMessageHandler*>(my_request->_provider);
     try     try
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,              AutoMutex lock(provider->status.getStatusMutex());
             "DefaultProviderManager::handleReferenceNamesRequest - Host name: $0  Name space: $1  Class name: $2",              //unload the provider
             System::getHostName(),              if (provider->status.isInitialized())
             request->nameSpace.getString(),              {
             request->objectName.getClassName().getString());                  dpmPtr->_unloadProvider(provider);
               }
         // make target object path              else
         CIMObjectPath objectPath(              {
             System::getHostName(),                  PEGASUS_ASSERT(0);
             request->nameSpace,              }
             request->objectName.getClassName());  
   
         objectPath.setKeyBindings(request->objectName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         STAT_GETSTARTTIME;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.referenceNames: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().referenceNames(  
             context,  
             objectPath,  
             request->resultClass,  
             request->role,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }     }
     catch(CIMException & e)     catch(CIMException & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s",
             "Exception: " + e.getMessage());                  (const char*)e.getMessage().getCString()));
               responseException = e;
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s",
             "Exception: " + e.getMessage());                  (const char*)e.getMessage().getCString()));
               responseException = CIMException(CIM_ERR_FAILED, e.getMessage());
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n          }
           catch (PEGASUS_STD(exception)& e)
           {
               responseException = CIMException(CIM_ERR_FAILED, e.what());
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
             "Exception: Unknown");             "Exception: Unknown");
               responseException = PEGASUS_CIM_EXCEPTION(
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");                  CIM_ERR_FAILED, "Unknown error.");
     }     }
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 } }
  
 Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw()      // delete the UnloadProviderRequest.
 {      delete request;
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");  
   
     CIMGetPropertyRequestMessage * request =  
         dynamic_cast<CIMGetPropertyRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
  
     // create response message      PEG_METHOD_EXIT();
     CIMGetPropertyResponseMessage * response =      return responseException;
         new CIMGetPropertyResponseMessage(  }
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         CIMValue());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
  
     //  Set HTTP method in response from request  PEGASUS_NAMESPACE_END
     response->setHttpMethod(request->getHttpMethod());  
  
     GetPropertyResponseHandler handler(request, response);  PEGASUS_USING_PEGASUS;
  
     try  // This entry point is not needed because the DefaultProviderManager is created
   // using DefaultProviderManager::createDefaultProviderManagerCallback().
   #if 0
   extern "C" PEGASUS_EXPORT ProviderManager* PegasusCreateProviderManager(
       const String& providerManagerName)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,      if (String::equalNoCase(providerManagerName, "Default"))
             "DefaultProviderManager::handleGetPropertyRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->instanceName.getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->instanceName.getClassName(),  
             request->instanceName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMName propertyName = request->propertyName;  
   
         STAT_GETSTARTTIME;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.getProperty: " +  
             ph.GetProvider().getName());  
   
         // forward request  
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().getProperty(  
             context,  
             objectPath,  
             propertyName,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          return new DefaultProviderManager();
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }     }
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
  
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n      return 0;
     }     }
     catch(...)  #endif
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");  
   
     CIMSetPropertyRequestMessage * request =  
         dynamic_cast<CIMSetPropertyRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     // create response message  
     //l10n  
     CIMSetPropertyResponseMessage * response =  
         new CIMSetPropertyResponseMessage(  
         request->messageId,  
         PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(  
         "ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED",  
         "not implemented")),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     SetPropertyResponseHandler handler(request, response);  
   
     try  
     {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "DefaultProviderManager::handleSetPropertyRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->instanceName.getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->instanceName.getClassName(),  
             request->instanceName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMName propertyName = request->propertyName;  
         CIMValue propertyValue = request->newValue;  
   
         STAT_GETSTARTTIME;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.setProperty: " +  
             ph.GetProvider().getName());  
   
         // forward request  
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().setProperty(  
             context,  
             objectPath,  
             propertyName,  
             propertyValue,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");  
   
     CIMInvokeMethodRequestMessage * request =  
         dynamic_cast<CIMInvokeMethodRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     // create response message  
     CIMInvokeMethodResponseMessage * response =  
         new CIMInvokeMethodResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         CIMValue(),  
         Array<CIMParamValue>(),  
         request->methodName);  
   
     PEGASUS_ASSERT(response != 0);  
   
     // propagate message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     // create a handler for this request  
     InvokeMethodResponseHandler handler(request, response);  
   
     try  
     {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "DefaultProviderManager::handleInvokeMethodRequest - Host name: $0  Name space: $1  Class name: $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             request->instanceName.getClassName().getString());  
   
         // make target object path  
         CIMObjectPath objectPath(  
             System::getHostName(),  
             request->nameSpace,  
             request->instanceName.getClassName(),  
             request->instanceName.getKeyBindings());  
   
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::METHOD,  
             request->methodName);  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMObjectPath instanceReference(request->instanceName);  
   
         // ATTN: propagate namespace  
         instanceReference.setNameSpace(request->nameSpace);  
   
         // forward request  
         STAT_GETSTARTTIME;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.invokeMethod: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().invokeMethod(  
             context,  
             instanceReference,  
             request->methodName,  
             request->inParameters,  
             handler);  
   
         STAT_PMS_PROVIDEREND;  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown error.");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");  
   
     CIMCreateSubscriptionRequestMessage * request =  
         dynamic_cast<CIMCreateSubscriptionRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMCreateSubscriptionResponseMessage * response =  
         new CIMCreateSubscriptionResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
         String temp;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             temp.append(request->classNames[i].getString());  
   
             if(i == (n - 1))  
             {  
                 temp.append(", ");  
             }  
         }  
   
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             temp);  
   
         String physicalName=_resolvePhysicalName(  
            request->providerModule.getProperty(  
            request->providerModule.findProperty("Location")).getValue().toString());  
   
         ProviderName name(String::EMPTY,  
            request->provider.getProperty(request->provider.findProperty  
               ("Name")).getValue ().toString (),  
            physicalName,  
            request->providerModule.getProperty(request->providerModule.findProperty  
               ("InterfaceType")).getValue().toString(),  
            0);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(SubscriptionInstanceContainer  
             (request->subscriptionInstance));  
         context.insert(SubscriptionFilterConditionContainer  
             (request->condition, request->queryLanguage));  
         context.insert(SubscriptionLanguageListContainer  
             (request->acceptLanguages));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();  
   
         Array<CIMObjectPath> classNames;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             CIMObjectPath className(  
                 System::getHostName(),  
                 request->nameSpace,  
                 request->classNames[i]);  
   
             classNames.append(className);  
         }  
   
         CIMPropertyList propertyList = request->propertyList;  
   
         Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.createSubscription: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().createSubscription(  
             context,  
             subscriptionName,  
             classNames,  
             propertyList,  
             repeatNotificationPolicy);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");  
   
     CIMModifySubscriptionRequestMessage * request =  
         dynamic_cast<CIMModifySubscriptionRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMModifySubscriptionResponseMessage * response =  
         new CIMModifySubscriptionResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
         String temp;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             temp.append(request->classNames[i].getString());  
   
             if(i == (n - 1))  
             {  
                 temp.append(", ");  
             }  
         }  
   
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             temp);  
   
         String physicalName=_resolvePhysicalName(  
            request->providerModule.getProperty(  
            request->providerModule.findProperty("Location")).getValue().toString());  
   
         ProviderName name(String::EMPTY,  
            request->provider.getProperty(request->provider.findProperty  
               ("Name")).getValue ().toString (),  
            physicalName,  
            request->providerModule.getProperty(request->providerModule.findProperty  
               ("InterfaceType")).getValue().toString(),  
            0);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(SubscriptionInstanceContainer  
             (request->subscriptionInstance));  
         context.insert(SubscriptionFilterConditionContainer  
             (request->condition, request->queryLanguage));  
         context.insert(SubscriptionLanguageListContainer  
             (request->acceptLanguages));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();  
   
         Array<CIMObjectPath> classNames;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             CIMObjectPath className(  
                 System::getHostName(),  
                 request->nameSpace,  
                 request->classNames[i]);  
   
             classNames.append(className);  
         }  
   
         CIMPropertyList propertyList = request->propertyList;  
   
         Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy;  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.modifySubscription: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().modifySubscription(  
             context,  
             subscriptionName,  
             classNames,  
             propertyList,  
             repeatNotificationPolicy);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");  
   
     CIMDeleteSubscriptionRequestMessage * request =  
         dynamic_cast<CIMDeleteSubscriptionRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMDeleteSubscriptionResponseMessage * response =  
         new CIMDeleteSubscriptionResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
         String temp;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             temp.append(request->classNames[i].getString());  
   
             if(i == (n - 1))  
             {  
                 temp.append(", ");  
             }  
         }  
   
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             "DefaultProviderManager::handleDeleteSubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",  
             System::getHostName(),  
             request->nameSpace.getString(),  
             temp);  
   
         String physicalName=_resolvePhysicalName(  
            request->providerModule.getProperty(  
            request->providerModule.findProperty("Location")).getValue().toString());  
   
         ProviderName name(String::EMPTY,  
            request->provider.getProperty(request->provider.findProperty  
               ("Name")).getValue ().toString (),  
            physicalName,  
            request->providerModule.getProperty(request->providerModule.findProperty  
               ("InterfaceType")).getValue().toString(),  
            0);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         // convert arguments  
         OperationContext context;  
   
         context.insert(IdentityContainer(request->userName));  
         context.insert(SubscriptionInstanceContainer  
             (request->subscriptionInstance));  
         context.insert(SubscriptionLanguageListContainer  
             (request->acceptLanguages));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();  
   
         Array<CIMObjectPath> classNames;  
   
         for(Uint32 i = 0, n = request->classNames.size(); i < n; i++)  
         {  
             CIMObjectPath className(  
                 System::getHostName(),  
                 request->nameSpace,  
                 request->classNames[i]);  
   
             classNames.append(className);  
         }  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.deleteSubscription: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().deleteSubscription(  
             context,  
             subscriptionName,  
             classNames);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");  
   
     CIMEnableIndicationsRequestMessage * request =  
         dynamic_cast<CIMEnableIndicationsRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMEnableIndicationsResponseMessage * response =  
         new CIMEnableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     CIMEnableIndicationsResponseMessage * responseforhandler =  
         new CIMEnableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     response->dest = request->queueIds.top();  
   
     // ATTN: need pointer to Provider Manager Server!  
     EnableIndicationsResponseHandler *handler =  
         new EnableIndicationsResponseHandler(request, response,  
               request->provider, ProviderManagerService::providerManagerService);  
   
     try  
     {  
        String physicalName=_resolvePhysicalName(  
           request->providerModule.getProperty(  
               request->providerModule.findProperty("Location")).getValue().toString());  
   
        ProviderName name(String::EMPTY,  
                request->provider.getProperty(request->provider.findProperty  
                    ("Name")).getValue ().toString (),  
                physicalName,  
                request->providerModule.getProperty(request->providerModule.findProperty  
                     ("InterfaceType")).getValue().toString(),  
                0);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.enableIndications: " +  
             ph.GetProvider().getName());  
   
         pm_service_op_lock op_lock(&ph.GetProvider());  
   
         ph.GetProvider().enableIndications(*handler);  
   
   
         // if no exception, store the handler so it is persistent for as  
         // long as the provider has indications enabled.  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Storing indication handler for " + ph.GetProvider().getName());  
   
         _insertEntry(ph.GetProvider(), handler);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         response->cimException = CIMException(e);  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",  
             "Internal Error"));  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",  
             "Unknown Error"));  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");  
   
     CIMDisableIndicationsRequestMessage * request =  
         dynamic_cast<CIMDisableIndicationsRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMDisableIndicationsResponseMessage * response =  
         new CIMDisableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
        String physicalName=_resolvePhysicalName(  
               request->providerModule.getProperty(  
                  request->providerModule.findProperty("Location")).getValue().toString());  
   
        ProviderName name(String::EMPTY,  
                request->provider.getProperty(request->provider.findProperty  
                    ("Name")).getValue ().toString (),  
                physicalName,  
                request->providerModule.getProperty(request->providerModule.findProperty  
                     ("InterfaceType")).getValue().toString(),  
             0);  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.disableIndications: " +  
             ph.GetProvider().getName());  
   
         ph.GetProvider().disableIndications();  
   
         ph.GetProvider().unprotect();  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Removing and Destroying indication handler for " +  
             ph.GetProvider().getName());  
   
         delete _removeEntry(_generateKey(ph.GetProvider()));  
     }  
   
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         response->cimException = CIMException(e);  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
             response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",  
             "Internal Error"));  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
             response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",  
             "Unknown Error"));  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest");  
   
     CIMConsumeIndicationRequestMessage *request =  
         dynamic_cast<CIMConsumeIndicationRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMResponseMessage * response =  
         new CIMResponseMessage(  
         CIM_CONSUME_INDICATION_RESPONSE_MESSAGE,  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     Uint32 type = 3;  
   
     try  
     {  
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         /*  
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             objectPath.toString());  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
         */  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.: " +  
             ph.GetProvider().getName());  
   
         OperationContext context;  
   
         //l10n  
         // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent.  This  
         // does not appear to be hooked-up.  When it is added, need to  
         // make sure that Content-Language is set in the consume msg.  
         // NOTE: A-L is not needed to be set in the consume msg.  
         // add the langs to the context  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
         CIMInstance indication_copy = request->indicationInstance;  
   
         SimpleIndicationResponseHandler handler;  
   
         ph.GetProvider().consumeIndication(context,  
             "",  
             indication_copy);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         response->cimException = CIMException(e);  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");  
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",  
             "Internal Error"));  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");  
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",  
             "Unknown Error"));  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
   
 Message *DefaultProviderManager::handleExportIndicationRequest(const Message *message) throw()  
 {  
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest");  
   
     CIMExportIndicationRequestMessage * request =  
         dynamic_cast<CIMExportIndicationRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMExportIndicationResponseMessage * response =  
         new CIMExportIndicationResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
        ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
        // resolve provider name  
        name = _resolveProviderName(request->destinationPath);  
   
        // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                        "Calling provider.: " +  
                        ph.GetProvider().getName());  
   
         OperationContext context;  
   
 //L10N_TODO  
 //l10n  
 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent.  This  
 // does not appear to be hooked-up.  When it is added, need to  
 // make sure that Content-Language is set in the consume msg.  
 // NOTE: A-L is not needed to be set in the consume msg.  
       // add the langs to the context  
       context.insert(ContentLanguageListContainer(request->contentLanguages));  
   
       CIMInstance indication_copy = request->indicationInstance;  
       pm_service_op_lock op_lock(&ph.GetProvider());  
   
       ph.GetProvider().consumeIndication(context,  
                                 request->destinationPath,  
                                 indication_copy);  
   
     }  
   
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
   
   
   
 //  
 // This function disables a provider module if disableProviderOnly is not true,  
 // otherwise, disables a provider. Disable provider module means that  
 // block all the providers which contain in the module and unload the  
 // providers.  
 // Disable provider means unload the provider and the provider is not blocked.  
 //  
 // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider.  
 //  
 Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");  
 if (getenv("DEB_HALT"))asm("int $3");  
     CIMDisableModuleRequestMessage * request =  
         dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     Array<Uint16> operationalStatus;  
     Boolean disableProviderOnly = request->disableProviderOnly;  
     CIMException cimException;  
   
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();  
   
     try  
     {  
         // get provider module name  
         String moduleName;  
         CIMInstance mInstance = request->providerModule;  
         Uint32 pos = mInstance.findProperty(CIMName ("Name"));  
   
         if(pos != PEG_NOT_FOUND)  
         {  
                 mInstance.getProperty(pos).getValue().get(moduleName);  
         }  
   
         Boolean disableProviderOnly = request->disableProviderOnly;  
   
         //  
         // get operational status  
         //  
         if (!disableProviderOnly)  
         {  
             Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus"));  
             if (pos2 != PEG_NOT_FOUND)  
             {  
                 //  
                 //  ATTN-CAKG-P2-20020821: Check for null status?  
                 //  
                 mInstance.getProperty(pos2).getValue().get(operationalStatus);  
             }  
   
             //  
             // update module status from OK to Stopping  
             //  
             for (Uint32 i=0, n = operationalStatus.size(); i < n; i++)  
             {  
                 if (operationalStatus[i] == _MODULE_OK)  
                 {  
                     operationalStatus.remove(i);  
                 }  
             }  
   
             operationalStatus.append(_MODULE_STOPPING);  
   
             if(_providerRegistrationManager->setProviderModuleStatus  
                 (moduleName, operationalStatus) == false)  
             {  
                 //l10n  
                 //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");  
                 throw PEGASUS_CIM_EXCEPTION_L(  
                     CIM_ERR_FAILED,  
                     MessageLoaderParms(  
                         "ProviderManager.ProviderManagerService."  
                             "SET_MODULE_STATUS_FAILED",  
                         "set module status failed."));  
             }  
         }  
   
         // Unload providers  
         Array<CIMInstance> _pInstances = request->providers;  
         Array<Boolean> _indicationProviders = request->indicationProviders;  
   
         String physicalName=_resolvePhysicalName(  
            mInstance.getProperty(  
               mInstance.findProperty("Location")).getValue().toString());  
   
         for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)  
         {  
             String pName(_pInstances[i].getProperty(  
                _pInstances[i].findProperty("Name")).getValue().toString());  
   
             Sint16 ret_value = providerManager.disableProvider(physicalName,pName);  
   
             if (ret_value == 0)  
             {  
                 // disable failed since there are pending requests,  
                 // update module status from Stopping to OK if  
                 // disableProviderOnly is not true  
                 if (!disableProviderOnly)  
                 {  
                     for(Uint32 j=0, m = operationalStatus.size(); j < m; j++)  
                     {  
                         if (operationalStatus[j] == _MODULE_STOPPING)  
                         {  
                             operationalStatus.remove(j);  
                         }  
                     }  
   
                     operationalStatus.append(_MODULE_OK);  
   
                     if(_providerRegistrationManager->setProviderModuleStatus  
                         (moduleName, operationalStatus) == false)  
                     {  
                         throw PEGASUS_CIM_EXCEPTION_L(  
                             CIM_ERR_FAILED,  
                             MessageLoaderParms(  
                                 "ProviderManager.ProviderManagerService."  
                                     "SET_MODULE_STATUS_FAILED",  
                                 "set module status failed."));  
                     }  
                 }  
             }  
             else if (ret_value == 1)  
             {  
                 // if It is an indication provider  
                 // remove the entry from the table since the  
                 // provider has been disabled  
                 if (_indicationProviders[i])  
                 {  
                     _removeEntry(_generateKey(pName,physicalName));  
                 }  
             }  
             else  
             {  
                 // disable failed for other reason, throw exception  
                 // update module status from Stopping to OK if  
                 // disableProviderOnly is not true  
                 if (!disableProviderOnly)  
                 {  
                     for(Uint32 j=0, m = operationalStatus.size(); j < m; j++)  
                     {  
                         if (operationalStatus[j] == _MODULE_STOPPING)  
                         {  
                             operationalStatus.remove(j);  
                         }  
                     }  
   
                     operationalStatus.append(_MODULE_OK);  
   
                     if(_providerRegistrationManager->setProviderModuleStatus  
                         (moduleName, operationalStatus) == false)  
                     {  
                         throw PEGASUS_CIM_EXCEPTION_L(  
                             CIM_ERR_FAILED,  
                             MessageLoaderParms(  
                                 "ProviderManager.ProviderManagerService."  
                                     "SET_MODULE_STATUS_FAILED",  
                                 "set module status failed."));  
                     }  
                 }  
   
                 throw PEGASUS_CIM_EXCEPTION_L(  
                     CIM_ERR_FAILED,  
                     MessageLoaderParms(  
                         "ProviderManager.ProviderManagerService."  
                             "DISABLE_PROVIDER_FAILED",  
                         "Failed to disable the provider."));  
             }  
         }  
         // disable succeed  
         // update module status from Stopping to Stopped if  
         // disableProviderOnly is not true  
         if (!disableProviderOnly)  
         {  
             // update module status from Stopping to Stopped  
             for(Uint32 j=0, m = operationalStatus.size(); j < m; j++)  
             {  
                 if (operationalStatus[j] == _MODULE_STOPPING)  
                 {  
                     operationalStatus.remove(j);  
                     operationalStatus.append(_MODULE_STOPPED);  
                 }  
             }  
   
             if(_providerRegistrationManager->setProviderModuleStatus  
                (moduleName, operationalStatus) == false)  
             {  
                 //l10n  
                 //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"set module status failed.");  
                 throw PEGASUS_CIM_EXCEPTION_L(  
                       CIM_ERR_FAILED,  
                       MessageLoaderParms(  
                       "ProviderManager.ProviderManagerService."  
                        "SET_MODULE_STATUS_FAILED",  
                        "set module status failed."));  
             }  
        }  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: " + e.getMessage());  
         cimException = e;  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: " + e.getMessage());  
         cimException = CIMException(CIM_ERR_FAILED, e.getMessage());  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                          "Exception: Unknown");  
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");  
         cimException = PEGASUS_CIM_EXCEPTION_L(  
             CIM_ERR_FAILED,  
             MessageLoaderParms(  
                 "ProviderManager.ProviderManagerService.UNKNOWN_ERROR",  
                 "Unknown Error"));  
     }  
   
     CIMDisableModuleResponseMessage * response =  
         new CIMDisableModuleResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         operationalStatus);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw()  
 {  
     // HACK  
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();  
   
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest");  
   
     CIMEnableModuleRequestMessage * request =  
         dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     //  
     // get module status  
     //  
     CIMInstance mInstance = request->providerModule;  
     Array<Uint16> operationalStatus;  
     Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus"));  
   
     if(pos != PEG_NOT_FOUND)  
     {  
         //  
         //  ATTN-CAKG-P2-20020821: Check for null status?  
         //  
         mInstance.getProperty(pos).getValue().get(operationalStatus);  
     }  
   
     // update module status from Stopped to OK  
     for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)  
     {  
         if(operationalStatus[i] == _MODULE_STOPPED)  
         {  
             operationalStatus.remove(i);  
         }  
     }  
   
     operationalStatus.append(_MODULE_OK);  
   
     //  
     // get module name  
     //  
     String moduleName;  
   
     Uint32 pos2 = mInstance.findProperty(CIMName ("Name"));  
   
     if(pos2 != PEG_NOT_FOUND)  
     {  
         mInstance.getProperty(pos2).getValue().get(moduleName);  
     }  
   
     if(_providerRegistrationManager->setProviderModuleStatus  
         (moduleName, operationalStatus) == false)  
     {  
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");  
         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",  
             "set module status failed."));  
     }  
   
     CIMEnableModuleResponseMessage * response =  
         new CIMEnableModuleResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop(),  
         operationalStatus);  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");  
   
     CIMStopAllProvidersRequestMessage * request =  
         dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMStopAllProvidersResponseMessage * response =  
         new CIMStopAllProvidersResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     // tell the provider manager to shutdown all the providers  
     providerManager.shutdownAllProviders();  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 void DefaultProviderManager::_insertEntry (  
     const Provider & provider,  
     const EnableIndicationsResponseHandler *handler)  
 {  
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,  
         "DefaultProviderManager::_insertEntry");  
   
     String tableKey = _generateKey  
         (provider);  
   
     _responseTable.insert (tableKey, const_cast<EnableIndicationsResponseHandler *>(handler));  
   
     PEG_METHOD_EXIT();  
 }  
   
 EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry(  
     const String & key)  
 {  
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,  
         "DefaultProviderManager::_removeEntry");  
     EnableIndicationsResponseHandler *ret = 0;  
   
     _responseTable.lookup(key, ret);  
     _responseTable.remove(key);         // why is this needed ? - we get killed when removed...  
   
     PEG_METHOD_EXIT();  
   
     return(ret);  
 }  
   
 String DefaultProviderManager::_generateKey (  
     const Provider & provider)  
 {  
     String tableKey;  
   
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,  
         "DefaultProviderManager::_generateKey");  
   
     //  
     //  Append provider key values to key  
     //  
     String providerName = provider.getName();  
     String providerFileName = provider.getModule()->getFileName();  
     tableKey.append (providerName);  
     tableKey.append (providerFileName);  
   
     PEG_METHOD_EXIT();  
   
     return(tableKey);  
 }  
   
 String DefaultProviderManager::_generateKey (  
     const String & providerName,  
     const String & providerFileName)  
 {  
     String tableKey;  
   
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,  
                       "DefaultProviderManagerService::_generateKey");  
   
     //  
     //  Append providerName and providerFileName to key  
     //  
     tableKey.append (providerName);  
     tableKey.append (providerFileName);  
   
     PEG_METHOD_EXIT ();  
     return tableKey;  
 }  
   
 ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName)  
 {  
     ProviderName temp = findProvider(providerName);  
   
     String physicalName = _resolvePhysicalName(temp.getPhysicalName());  
   
     temp.setPhysicalName(physicalName);  
   
     return(temp);  
 }  
   
 ProviderName DefaultProviderManager::_resolveProviderName(String & destinationPath)  
 {  
     ProviderName temp = findProvider(destinationPath);  
   
     String physicalName = _resolvePhysicalName(temp.getPhysicalName());  
   
     temp.setPhysicalName(physicalName);  
   
     return(temp);  
 }  
   
 PEGASUS_NAMESPACE_END  

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