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

Diff for /pegasus/src/Pegasus/ProviderManager2/Attic/ProviderManagerService.cpp between version 1.6 and 1.61

version 1.6, 2003/08/21 19:36:25 version 1.61, 2005/01/20 22:05:19
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2004////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 28 
Line 32 
 //              Mike Day, IBM (mdday@us.ibm.com) //              Mike Day, IBM (mdday@us.ibm.com)
 //              Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. //              Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.
 //                      Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) //                      Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
   //              Adrian Schuur, IBM (schuur@de.ibm.com)
   //              Amit K Arora (amita@in.ibm.com) for PEP-101
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Seema Gupta (gseema@in.ibm.com for PEP135)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 36 
Line 44 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
   #include <Pegasus/Common/Thread.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/Destroyer.h>  #include <Pegasus/Common/AutoPtr.h>
   #include <Pegasus/Common/Constants.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
 PEGASUS_NAMESPACE_BEGIN  #include <Pegasus/ProviderManager2/BasicProviderManagerRouter.h>
   #include <Pegasus/ProviderManager2/OOPProviderManagerRouter.h>
 // ATTN: this section is a temporary solution to populate the list of enabled  #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
 // provider managers for a given distribution. it includes another temporary  
 // solution for converting a generic file name into a file name useable by  
 // each platform.  
   
 // BEGIN TEMP SECTION  
 String _resolveFileName(const String & fileName)  
 {  
     String temp;  
   
     #if defined(PEGASUS_OS_TYPE_WINDOWS)  
     temp = fileName + String(".dll");  
     #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)  
     temp = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
     temp.append(String("/lib") + fileName + String(".sl"));  
     #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)  
     temp = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
     temp.append(String("/lib") + fileName + String(".so"));  
     #elif defined(PEGASUS_OS_OS400)  
     temp = fileName;  
     #else  
     temp = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
     temp.append(String("/lib") + fileName + String(".so"));  
     #endif  
   
     return(temp);  
 }  
  
 Array<Pair<String, String> > _initializeFileNames(void)  PEGASUS_NAMESPACE_BEGIN
 {  
     Array<Pair<String, String> > temp;  
   
     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)  
     temp.append(Pair<String, String>(_resolveFileName("DefaultProviderManager"), String("DEFAULT")));  
     #endif  
   
     #if defined(ENABLE_CMPI_PROVIDER_MANAGER)  
     temp.append(Pair<String, String>(_resolveFileName("CMPIProviderManager"), String("CMPI")));  
     #endif  
   
     return(temp);  
 }  
   
 static const Array<Pair<String,String> > _fileNames = _initializeFileNames();  
 // END TEMP SECTION  
  
 inline Boolean _isSupportedRequestType(const Message * message) inline Boolean _isSupportedRequestType(const Message * message)
 { {
     Boolean rc = false;      // ATTN: needs implementation
  
     if(message == 0)      // for now, assume all requests are valid
     {  
         return(rc);  
     }  
   
     /*  
     // ATTN : need to determine valid request message types  
     // before enabling.  
   
     switch(message->getType())  
     {  
     case CIM_GET_INSTANCE_REQUEST_MESSAGE:  
     case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:  
     case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:  
     case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:  
     case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:  
     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:  
     case CIM_EXEC_QUERY_REQUEST_MESSAGE:  
     case CIM_ASSOCIATORS_REQUEST_MESSAGE:  
     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:  
     case CIM_REFERENCES_REQUEST_MESSAGE:  
     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:  
     case CIM_GET_PROPERTY_REQUEST_MESSAGE:  
     case CIM_SET_PROPERTY_REQUEST_MESSAGE:  
     case CIM_INVOKE_METHOD_REQUEST_MESSAGE:  
     case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:  
     case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:  
     case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:  
     case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:  
     case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:  
     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:  
     case CIM_ENABLE_MODULE_REQUEST_MESSAGE:  
     case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:  
     case CIM_CONSUME_INDICATION_REQUEST_MESSAGE:  
         rc = true;  
   
         break;  
     default:  
         rc = false;  
   
         break;  
     }  
     */  
   
     rc = true;  
  
     return(rc);      return(true);
 } }
  
 inline Boolean _isSupportedResponseType(const Message * message) inline Boolean _isSupportedResponseType(const Message * message)
 { {
     Boolean rc = false;      // ATTN: needs implementation
  
     return(rc);      // for now, assume all responses are invalid
   
       return(false);
 } }
  
   ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
   Uint32 ProviderManagerService::_indicationServiceQueueId = PEG_NOT_FOUND;
   
 ProviderManagerService::ProviderManagerService(void) ProviderManagerService::ProviderManagerService(void)
     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
 { {
       providerManagerService=this;
 } }
  
 ProviderManagerService::ProviderManagerService(ProviderRegistrationManager * providerRegistrationManager)  ProviderManagerService::ProviderManagerService(
           ProviderRegistrationManager * providerRegistrationManager,
           CIMRepository * repository)
     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
 { {
     for(Uint32 i = 0, n = _fileNames.size(); i < n; i++)      providerManagerService=this;
     {      _repository=repository;
         String message;  
   
         message = "ProviderManagerService::ProviderManagerService() loading " +  
             _fileNames[i].first + "(" + _fileNames[i].second + ")";  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, message);  
   
         try  
         {  
             ProviderManagerModule module(_fileNames[i].first);  
  
             if(module.load() == false)      _providerRegistrationManager = providerRegistrationManager;
             {  
                 throw 0;    // ATTN: inefficient  
             }  
  
             ProviderManager * manager = module.getProviderManager(_fileNames[i].second);      _unloadIdleProvidersBusy = 0;
  
             if(manager == 0)      // Determine whether Out-of-Process Provider support is enabled
       ConfigManager* configManager = ConfigManager::getInstance();
       if (String::equal(
           configManager->getCurrentValue("forceProviderProcesses"), "true"))
             {             {
                 throw 0;    // ATTN: inefficient          _providerManagerRouter =
             }              new OOPProviderManagerRouter(indicationCallback);
   
             // ATTN: only set the hacked/cached provider registration manager pointer after the  
             // DEFAULT provider manager is loaded.  
             if(String::equalNoCase(_fileNames[i].second, "DEFAULT"))  
             {  
                 manager->setProviderRegistrationManager(providerRegistrationManager);  
             }  
   
             _providerManagers.append(Pair<ProviderManager *, ProviderManagerModule>(manager, module));  
         }         }
         catch(...)      else
         {         {
             message = "ProviderManagerService::ProviderManagerService() exception loading " +          _providerManagerRouter =
                 _fileNames[i].first + "(" + _fileNames[i].second + ")";              new BasicProviderManagerRouter(indicationCallback);
   
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, message);  
         }  
     }     }
 } }
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
       delete _providerManagerRouter;
       providerManagerService=NULL;
 } }
  
 Boolean ProviderManagerService::messageOK(const Message * message) Boolean ProviderManagerService::messageOK(const Message * message)
Line 261 
Line 173 
  
         _incomingQueue.enqueue(request->op);         _incomingQueue.enqueue(request->op);
  
         _thread_pool->allocate_and_awaken((void *)this, ProviderManagerService::handleCimOperation);           while (!_thread_pool->allocate_and_awaken(
                        (void *)this, ProviderManagerService::handleCimOperation))
            {
                pegasus_yield();
            }
     }     }
     else     else
     {     {
Line 274 
Line 190 
     return;     return;
 } }
  
 /*  // Note: This method should not throw an exception.  It is used as a thread
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleServiceOperation(void * arg) throw()  // entry point, and any exceptions thrown are ignored.
   PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL
   ProviderManagerService::handleCimOperation(void * arg)
 { {
     // get the service from argument      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
     ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);          "ProviderManagerService::handleCimOperation");
   
     PEGASUS_ASSERT(service != 0);  
   
     // get message from service queue  
     Message * message = service->_incomingQueue.dequeue();  
   
     PEGASUS_ASSERT(message != 0);  
   
     if(service->_incomingQueue.size() == 0)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "ProviderManagerService::handleCimOperation() called with no op node in queue" );  
   
         PEG_METHOD_EXIT();  
   
         // thread started with no message in queue.  
         return(PEGASUS_THREAD_RETURN(1));  
     }  
   
     AsyncOpNode * op = service->_incomingQueue.dequeue();  
   
     PEGASUS_ASSERT(op != 0 );  
  
     if(op->_request.count() == 0)      if(arg == 0)
     {     {
         MessageQueue * queue = MessageQueue::lookup(op->_source_queue);          // thread started with invalid argument.
   
         PEGASUS_ASSERT(queue != 0);  
   
         PEG_METHOD_EXIT();  
   
         // no request in op node  
         return(PEGASUS_THREAD_RETURN(1));         return(PEGASUS_THREAD_RETURN(1));
     }     }
  
     return(0);  
 }  
 */  
   
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimOperation");  
   
     // get the service from argument     // get the service from argument
     ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);      ProviderManagerService * service =
           reinterpret_cast<ProviderManagerService *>(arg);
     PEGASUS_ASSERT(service != 0);  
  
     if(service->_incomingQueue.size() == 0)     if(service->_incomingQueue.size() == 0)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "ProviderManagerService::handleCimOperation() called with no op node in queue" );              "ProviderManagerService::handleCimOperation() called with no "
                   "op node in queue");
  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
  
Line 340 
Line 222 
  
     AsyncOpNode * op = service->_incomingQueue.dequeue();     AsyncOpNode * op = service->_incomingQueue.dequeue();
  
     PEGASUS_ASSERT(op != 0 );      if((op == 0) || (op->_request.count() == 0))
   
     if(op->_request.count() == 0)  
     {     {
           // ATTN: This may dereference a null pointer!
         MessageQueue * queue = MessageQueue::lookup(op->_source_queue);         MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
  
         PEGASUS_ASSERT(queue != 0);         PEGASUS_ASSERT(queue != 0);
Line 356 
Line 237 
  
     AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));     AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));
  
     PEGASUS_ASSERT(request != 0);      if ((request == 0) ||
           (request->getType() != async_messages::ASYNC_LEGACY_OP_START))
     if(request->getType() != async_messages::ASYNC_LEGACY_OP_START)  
     {     {
         // reply with NAK         // reply with NAK
   
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
   
         return(PEGASUS_THREAD_RETURN(0));         return(PEGASUS_THREAD_RETURN(0));
     }     }
  
     Message * legacy = static_cast<AsyncLegacyOperationStart *>(request)->get_action();      try
       {
           Message* legacy =
               static_cast<AsyncLegacyOperationStart *>(request)->get_action();
  
     if(_isSupportedRequestType(legacy))     if(_isSupportedRequestType(legacy))
     {     {
         Destroyer<Message> xmessage(legacy);              AutoPtr<Message> xmessage(legacy);
  
         // Set the client's requested language into this service thread.         // Set the client's requested language into this service thread.
         // This will allow functions in this service to return messages         // This will allow functions in this service to return messages
Line 380 
Line 261 
  
         if(msg != 0)         if(msg != 0)
         {         {
             AcceptLanguages * langs = new AcceptLanguages(msg->acceptLanguages);                          AcceptLanguages* langs =
                       new AcceptLanguages(((AcceptLanguageListContainer)msg->operationContext.get
                                                                                           (AcceptLanguageListContainer::NAME)).getLanguages());
             Thread::setLanguages(langs);             Thread::setLanguages(langs);
         }         }
         else         else
Line 389 
Line 271 
             Thread::clearLanguages();             Thread::clearLanguages();
         }         }
  
         try  
         {  
             service->handleCimRequest(op, legacy);             service->handleCimRequest(op, legacy);
         }         }
       }
         catch(...)         catch(...)
         {         {
             // ATTN: log error             // ATTN: log error
         }         }
     }  
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  
     return(PEGASUS_THREAD_RETURN(0));     return(PEGASUS_THREAD_RETURN(0));
 } }
  
 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, const Message * message) throw()  void ProviderManagerService::handleCimRequest(
       AsyncOpNode * op,
       Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::handleCimRequest");
  
     // ATTN: ensure message is a request???      CIMRequestMessage * request = dynamic_cast<CIMRequestMessage *>(message);
     CIMMessage * request = dynamic_cast<CIMMessage *>(const_cast<Message *>(message));      PEGASUS_ASSERT(request != 0);
  
     // get request from op node     // get request from op node
     AsyncRequest * async = static_cast<AsyncRequest *>(op->_request.next(0));     AsyncRequest * async = static_cast<AsyncRequest *>(op->_request.next(0));
       PEGASUS_ASSERT(async != 0);
     PEGASUS_ASSERT((request != 0) && (async != 0));  
  
     Message * response = 0;     Message * response = 0;
       Boolean consumerLookupFailed = false;
   
       if (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE)
       {
           //
           // Get a ProviderIdContainer for ExportIndicationRequestMessage.
           // Note: This can be removed when the CIMExportRequestDispatcher
           // is updated to add the ProviderIdContainer to the message.
           //
           CIMInstance providerModule;
           CIMInstance provider;
           const CIMExportIndicationRequestMessage* expRequest =
               dynamic_cast<const CIMExportIndicationRequestMessage*>(request);
           if (_providerRegistrationManager->lookupIndicationConsumer(
                   expRequest->destinationPath, provider, providerModule))
           {
               request->operationContext.insert(
                   ProviderIdContainer(providerModule, provider));
           }
           else
           {
               consumerLookupFailed = true;
           }
       }
   
       if (consumerLookupFailed)
       {
           CIMResponseMessage* cimResponse = request->buildResponse();
           cimResponse->cimException = PEGASUS_CIM_EXCEPTION(
               CIM_ERR_NOT_SUPPORTED, String::EMPTY);
           response = cimResponse;
       }
       else if ((dynamic_cast<CIMOperationRequestMessage*>(request) != 0) ||
           (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0) ||
           (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE) ||
           (request->getType() == CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE))
       {
           // Handle CIMOperationRequestMessage, CIMExportIndicationRequestMessage,
           // CIMIndicationRequestMessage, and CIMInitializeProviderRequestMessage.
           // (These should be blocked when the provider module is disabled.)
  
     // find provider manager          //
     // ATTN: implement efficient lookup          // Get the provider module instance to check for a disabled module
     ProviderManager * manager = _providerManagers[0].first;          //
           CIMInstance providerModule;
   
           // The provider ID container is added to the OperationContext
           // by the CIMOperationRequestDispatcher for all CIM operation
           // requests to providers, so it does not need to be added again.
           // CIMInitializeProviderRequestMessage also has a provider ID
           // container.
           ProviderIdContainer pidc =
               request->operationContext.get(ProviderIdContainer::NAME);
           providerModule = pidc.getModule();
   
           //
           // Check if the target provider is disabled
           //
           Boolean moduleDisabled = false;
           Uint32 pos = providerModule.findProperty(CIMName("OperationalStatus"));
           PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
           Array<Uint16> operationalStatus;
           providerModule.getProperty(pos).getValue().get(operationalStatus);
   
           for(Uint32 i = 0; i < operationalStatus.size(); i++)
           {
               if ((operationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED) ||
                   (operationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING))
               {
                   moduleDisabled = true;
                   break;
               }
           }
   
           if (moduleDisabled)
           {
               //
               // Send a "provider blocked" response
               //
               CIMResponseMessage* cimResponse = request->buildResponse();
               cimResponse->cimException = PEGASUS_CIM_EXCEPTION_L(
                   CIM_ERR_ACCESS_DENIED,
                   MessageLoaderParms(
                       "ProviderManager.ProviderManagerService.PROVIDER_BLOCKED",
                       "provider blocked."));
               response = cimResponse;
           }
           else
           {
               //
               // Forward the request to the appropriate ProviderManagerRouter
               //
               response = _providerManagerRouter->processMessage(request);
           }
       }
       else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
       {
           // Handle CIMEnableModuleRequestMessage
           CIMEnableModuleRequestMessage * emReq =
               dynamic_cast<CIMEnableModuleRequestMessage*>(request);
   
           CIMInstance providerModule = emReq->providerModule;
  
     try     try
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              // Forward the request to the ProviderManager
             "ProviderManagerService::handleCimRequest() passing control to provider manager.");              response = _providerManagerRouter->processMessage(request);
  
         // forward request              // If successful, update provider module status to OK
         response = manager->processMessage(request);              // ATTN: Use CIMEnableModuleResponseMessage operationalStatus?
               CIMEnableModuleResponseMessage * emResp =
                   dynamic_cast<CIMEnableModuleResponseMessage*>(response);
               if (emResp->cimException.getCode() == CIM_ERR_SUCCESS)
               {
                   _updateProviderModuleStatus(
                       providerModule, CIM_MSE_OPSTATUS_VALUE_STOPPED,
                       CIM_MSE_OPSTATUS_VALUE_OK);
     }     }
     catch(...)          }
           catch (Exception& e)
           {
               // Get the OperationalStatus property from the provider module
               Array<Uint16> operationalStatus;
               CIMValue itValue = emReq->providerModule.getProperty(
                   emReq->providerModule.findProperty("OperationalStatus"))
                       .getValue();
               itValue.get(operationalStatus);
   
               if (response != 0)
               {
                   delete response;
               }
   
               response = new CIMEnableModuleResponseMessage(
                   request->messageId,
                   CIMException(CIM_ERR_FAILED, e.getMessage()),
                   request->queueIds.copyAndPop(),
                   operationalStatus);
           }
       }
       else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
       {
           // Handle CIMDisableModuleRequestMessage
           CIMDisableModuleRequestMessage * dmReq =
               dynamic_cast<CIMDisableModuleRequestMessage*>(request);
   
           CIMInstance providerModule = dmReq->providerModule;
           Boolean updateModuleStatus = !dmReq->disableProviderOnly;
   
           try
           {
               // Change module status from OK to STOPPING
               if (updateModuleStatus)
     {     {
         // ATTN: create response with error message                  _updateProviderModuleStatus(
                       providerModule, CIM_MSE_OPSTATUS_VALUE_OK,
                       CIM_MSE_OPSTATUS_VALUE_STOPPING);
     }     }
  
     // preserve message key              // Forward the request to the ProviderManager
     response->setKey(request->getKey());              response = _providerManagerRouter->processMessage(request);
  
     // set HTTP method in response from request              // Update provider module status based on success or failure
     response->setHttpMethod(request->getHttpMethod());              if (updateModuleStatus)
               {
                   CIMDisableModuleResponseMessage * dmResp =
                       dynamic_cast<CIMDisableModuleResponseMessage*>(response);
                   if (dmResp->cimException.getCode() != CIM_ERR_SUCCESS)
                   {
                       // Disable operation failed.  Module not stopped.
                       _updateProviderModuleStatus(
                           providerModule, CIM_MSE_OPSTATUS_VALUE_STOPPING,
                           CIM_MSE_OPSTATUS_VALUE_OK);
                   }
                   else
                   {
                       // Disable may or may not have been successful,
                       // depending on whether there are outstanding requests.
                       // Use last operationalStatus entry.
                       _updateProviderModuleStatus(
                           providerModule, CIM_MSE_OPSTATUS_VALUE_STOPPING,
                           dmResp->operationalStatus[
                               dmResp->operationalStatus.size()-1]);
                   }
               }
           }
           catch (Exception& e)
           {
               // Get the OperationalStatus property from the provider module
               Array<Uint16> operationalStatus;
               CIMValue itValue = dmReq->providerModule.getProperty(
                   dmReq->providerModule.findProperty("OperationalStatus"))
                       .getValue();
               itValue.get(operationalStatus);
   
               if (response != 0)
               {
                   delete response;
               }
   
               response = new CIMDisableModuleResponseMessage(
                   request->messageId,
                   CIMException(CIM_ERR_FAILED, e.getMessage()),
                   request->queueIds.copyAndPop(),
                   operationalStatus);
           }
       }
       else
       {
           response = _providerManagerRouter->processMessage(request);
       }
  
     AsyncLegacyOperationResult * async_result =     AsyncLegacyOperationResult * async_result =
         new AsyncLegacyOperationResult(         new AsyncLegacyOperationResult(
Line 453 
Line 523 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void ProviderManagerService::unload_idle_providers(void)  void
   ProviderManagerService::handleCimResponse(CIMRequestMessage &request,
                                                                                                                                                                           CIMResponseMessage &response)
   {
           CIMStatusCode code = CIM_ERR_SUCCESS;
           String message;
   
           try
           {
                   // only incomplete messages are processed because the caller ends up
                   // sending the complete() stage
                   PEGASUS_ASSERT(response.isComplete() == false);
   
                   AsyncLegacyOperationStart *requestAsync =
                           dynamic_cast<AsyncLegacyOperationStart *>(request._async);
                   PEGASUS_ASSERT(requestAsync);
                   AsyncOpNode *op = requestAsync->op;
                   PEGASUS_ASSERT(op);
                   PEGASUS_ASSERT(! response._async);
                   response._async = new AsyncLegacyOperationResult
                           (requestAsync->getKey(), requestAsync->getRouting(), op, &response);
   
                   // set the destination
                   op->_op_dest = op->_callback_response_q;
   
                   MessageQueueService *service =
                           dynamic_cast<MessageQueueService *>(op->_callback_response_q);
   
                   PEGASUS_ASSERT(service);
   
                   // the last chunk MUST be sent last, so use execute the callback
                   // not all chunks are going through the dispatcher's chunk
                   // resequencer, so this must be a synchronous call here
                   // After the call is done, response and asyncResponse are now invalid
                   // as they have been sent and deleted externally
   
                   op->_async_callback(op, service, op->_callback_ptr);
           }
   
           catch(CIMException &e)
           {
                   code = e.getCode();
                   message = e.getMessage();
           }
           catch(Exception &e)
 { {
                   code = CIM_ERR_FAILED;
                   message = e.getMessage();
           }
           catch(...)
           {
                   code = CIM_ERR_FAILED;
                   message = cimStatusCodeToString(code);
           }
   
           if (code !=  CIM_ERR_SUCCESS)
                   response.cimException = PEGASUS_CIM_EXCEPTION(code, message);
   }
   
   void ProviderManagerService::unloadIdleProviders()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::unloadIdleProviders");
   
       // Ensure that only one _unloadIdleProvidersHandler thread runs at a time
       _unloadIdleProvidersBusy++;
       if ((_unloadIdleProvidersBusy.value() == 1) &&
           (_thread_pool->allocate_and_awaken(
                (void*)this, ProviderManagerService::_unloadIdleProvidersHandler)))
       {
           // _unloadIdleProvidersBusy is decremented in
           // _unloadIdleProvidersHandler
       }
       else
       {
           // If we fail to allocate a thread, don't retry now.
           _unloadIdleProvidersBusy--;
       }
   
       PEG_METHOD_EXIT();
   }
   
   PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL
   ProviderManagerService::_unloadIdleProvidersHandler(void* arg) throw()
   {
       try
       {
           PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
               "ProviderManagerService::unloadIdleProvidersHandler");
   
           ProviderManagerService* myself =
               reinterpret_cast<ProviderManagerService*>(arg);
   
           try
           {
               myself->_providerManagerRouter->unloadIdleProviders();
           }
           catch (...)
           {
               // Ignore errors
               PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                   "Unexpected exception in _unloadIdleProvidersHandler");
           }
   
           myself->_unloadIdleProvidersBusy--;
           PEG_METHOD_EXIT();
       }
       catch (...)
       {
           // Ignore errors
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
               "Unexpected exception in _unloadIdleProvidersHandler");
       }
   
       return(PEGASUS_THREAD_RETURN(0));
   }
   
   // Updates the providerModule instance and the ProviderRegistrationManager
   void ProviderManagerService::_updateProviderModuleStatus(
       CIMInstance& providerModule,
       Uint16 fromStatus,
       Uint16 toStatus)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::_updateProviderModuleStatus");
   
       Array<Uint16> operationalStatus;
       String providerModuleName;
   
       Uint32 pos = providerModule.findProperty(CIMName("Name"));
       PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
       providerModule.getProperty(pos).getValue().get(providerModuleName);
   
       //
       // get operational status
       //
       pos = providerModule.findProperty(CIMName("OperationalStatus"));
       PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
       CIMProperty operationalStatusProperty = providerModule.getProperty(pos);
       CIMValue operationalStatusValue = operationalStatusProperty.getValue();
   
       if (!operationalStatusValue.isNull())
       {
           operationalStatusValue.get(operationalStatus);
       }
   
       //
       // update module status
       //
       for (Uint32 i = operationalStatus.size(); i > 0; i--)
       {
           if (operationalStatus[i-1] == fromStatus)
           {
               operationalStatus.remove(i-1);
           }
       }
   
       operationalStatus.append(toStatus);
   
       if (_providerRegistrationManager->setProviderModuleStatus(
               providerModuleName, operationalStatus) == false)
       {
           throw PEGASUS_CIM_EXCEPTION_L(
               CIM_ERR_FAILED,
               MessageLoaderParms(
                   "ProviderManager.ProviderManagerService."
                       "SET_MODULE_STATUS_FAILED",
                   "set module status failed."));
       }
   
       operationalStatusProperty.setValue(CIMValue(operationalStatus));
   
       PEG_METHOD_EXIT();
   }
   
   void ProviderManagerService::indicationCallback(
       CIMProcessIndicationRequestMessage* request)
   {
           try
           {
                   AcceptLanguageListContainer cntr = request->operationContext.get(AcceptLanguageListContainer::NAME);
           }catch(const Exception &)
           {
                   request->operationContext.insert(AcceptLanguageListContainer(AcceptLanguages::EMPTY));
           }
   
           if (_indicationServiceQueueId == PEG_NOT_FOUND)
       {
           Array<Uint32> serviceIds;
   
           providerManagerService->find_services(
               PEGASUS_QUEUENAME_INDICATIONSERVICE, 0, 0, &serviceIds);
           PEGASUS_ASSERT(serviceIds.size() != 0);
   
           _indicationServiceQueueId = serviceIds[0];
       }
   
       request->queueIds = QueueIdStack(
           _indicationServiceQueueId, providerManagerService->getQueueId());
   
       AsyncLegacyOperationStart * asyncRequest =
           new AsyncLegacyOperationStart(
           providerManagerService->get_next_xid(),
           0,
           _indicationServiceQueueId,
           request,
           _indicationServiceQueueId);
   
       providerManagerService->SendForget(asyncRequest);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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