(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.18 and 1.41

version 1.18, 2003/10/30 23:31:27 version 1.41, 2004/05/22 13:23:12
Line 30 
Line 30 
 //              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 38 
Line 42 
 #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/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
 #include <Pegasus/ProviderManager2/ProviderManagerModule.h>  #include <Pegasus/ProviderManager2/BasicProviderManagerRouter.h>
 #include <Pegasus/ProviderManager2/ProviderManager.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // BEGIN TEMP SECTION  static const Uint16 _MODULE_OK       = 2;
 class ProviderManagerContainer  static const Uint16 _MODULE_STOPPING = 9;
 {  static const Uint16 _MODULE_STOPPED  = 10;
 public:  
     ProviderManagerContainer(void) : _manager(0)  
     {  
     }  
   
     ProviderManagerContainer(const ProviderManagerContainer & container) : _manager(0)  
     {  
         *this = container;  
     }  
   
     ProviderManagerContainer(const String & physicalName, const String & logicalName, const String & interfaceName) : _manager(0)  
     {  
         #if defined(PEGASUS_OS_TYPE_WINDOWS)  
         _physicalName = physicalName + String(".dll");  
         #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)  
         _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
         _physicalName.append(String("/lib") + physicalName + String(".sl"));  
         #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)  
         _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
         _physicalName.append(String("/lib") + physicalName + String(".so"));  
         #elif defined(PEGASUS_OS_OS400)  
         _physicalName = physicalName;  
         #else  
         _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
         _physicalName.append(String("/lib") + physicalName + String(".so"));  
         #endif  
   
         _logicalName = logicalName;  
   
         _interfaceName = interfaceName;  
   
         _module = ProviderManagerModule(_physicalName);  
   
         _module.load();  
   
         _manager = _module.getProviderManager(_logicalName);  
   
         PEGASUS_ASSERT(_manager != 0);  
     }  
   
     ~ProviderManagerContainer(void)  
     {  
         _module.unload();  
     }  
   
     ProviderManagerContainer & operator=(const ProviderManagerContainer & container)  
     {  
         if(this == &container)  
         {  
             return(*this);  
         }  
   
         _logicalName = container._logicalName;  
         _physicalName = container._physicalName;  
         _interfaceName = container._interfaceName;  
   
         _module = container._module;  
         _manager = container._manager;  
   
         return(*this);  
     }  
   
     ProviderManager & getProviderManager(void)  
     {  
         return(*_manager);  
     }  
   
     const String & getPhysicalName(void) const  
     {  
         return(_physicalName);  
     }  
   
     const String & getLogicalName(void) const  
     {  
         return(_logicalName);  
     }  
   
     const String & getInterfaceName(void) const  
     {  
         return(_interfaceName);  
     }  
   
 private:  
     String _physicalName;  
     String _logicalName;  
     String _interfaceName;  
   
     ProviderManagerModule _module;  
     ProviderManager * _manager;  
   
 };  
   
 static Array<ProviderManagerContainer> _providerManagers;  
 // END TEMP SECTION  
  
 inline Boolean _isSupportedRequestType(const Message * message) inline Boolean _isSupportedRequestType(const Message * message)
 { {
Line 165 
Line 75 
     return(false);     return(false);
 } }
  
   ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
   CIMRepository* ProviderManagerService::_repository=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)
 { {
     SetProviderRegistrationManager(providerRegistrationManager);      providerManagerService=this;
       _repository=repository;
  
     // ATTN: this section is a temporary solution to populate the list of enabled      _providerRegistrationManager = providerRegistrationManager;
     // provider managers for a given distribution. it includes another temporary      _providerManagerRouter =
     // solution for converting a generic file name into a file name useable by          new BasicProviderManagerRouter(indicationCallback);
     // each platform.  
   
     // BEGIN TEMP SECTION  
     //#if defined(PEGASUS_OS_OS400)  
     //_providerManagers.append(ProviderManagerContainer("QSYS/??????????", "INTERNAL", "INTERNAL"));  
     //#else  
     //_providerManager.append(ProviderManagerContainer("InternalProviderManager", "DEFAULT", "INTERNAL"));  
     //#endif  
   
     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)  
     #if defined(PEGASUS_OS_OS400)  
     _providerManagers.append(ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));  
     #else  
     _providerManagers.append(ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));  
     #endif  
     #endif  
   
     #if defined(ENABLE_CMPI_PROVIDER_MANAGER)  
     #if defined(PEGASUS_OS_OS400)  
     _providerManagers.append(ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));  
     #else  
     _providerManagers.append(ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));  
     #endif  
     #endif  
     // END TEMP SECTION  
 } }
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
       delete _providerManagerRouter;
       providerManagerService=NULL;
 } }
  
 Boolean ProviderManagerService::messageOK(const Message * message) Boolean ProviderManagerService::messageOK(const Message * message)
Line 264 
Line 159 
  
         _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 277 
Line 176 
     return;     return;
 } }
  
 /*  PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleServiceOperation(void * arg) throw()  ProviderManagerService::handleCimOperation(void * arg) throw()
 { {
     // 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)  
     {  
         MessageQueue * queue = MessageQueue::lookup(op->_source_queue);  
   
         PEGASUS_ASSERT(queue != 0);  
   
         PEG_METHOD_EXIT();  
   
         // no request in op node  
         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");  
  
     if(arg == 0)     if(arg == 0)
     {     {
Line 332 
Line 189 
     }     }
  
     // get the service from argument     // get the service from argument
     ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);      ProviderManagerService * service =
           reinterpret_cast<ProviderManagerService *>(arg);
  
     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 349 
Line 208 
  
     if((op == 0) || (op->_request.count() == 0))     if((op == 0) || (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 361 
Line 221 
  
     AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));     AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));
  
     if((request == 0) || (request->getType() != async_messages::ASYNC_LEGACY_OP_START))      if ((request == 0) ||
           (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));
     }     }
  
     try     try
     {     {
         Message * legacy = static_cast<AsyncLegacyOperationStart *>(request)->get_action();          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 385 
Line 245 
  
             if(msg != 0)             if(msg != 0)
             {             {
                 AcceptLanguages * langs = new AcceptLanguages(msg->acceptLanguages);                  AcceptLanguages* langs =
                       new AcceptLanguages(msg->acceptLanguages);
                 Thread::setLanguages(langs);                 Thread::setLanguages(langs);
             }             }
             else             else
Line 407 
Line 267 
     return(PEGASUS_THREAD_RETURN(0));     return(PEGASUS_THREAD_RETURN(0));
 } }
  
 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, const Message * message)  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;
  
     // get namespace and class name from message      if ((dynamic_cast<CIMOperationRequestMessage*>(request) != 0) ||
     String nameSpace;          (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE) ||
     String className;          (request->getType() == CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE))
   
     switch(message->getType())  
     {  
     case CIM_GET_CLASS_REQUEST_MESSAGE:  
         {         {
             const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);          // Handle CIMOperationRequestMessage and CIMExportIndicationRequestMessage
                   // The provider ID container is already added to operationcontext in CIMOperationRequestDispacther
                   // for all instance, method , association and indication providers under PEP135 , so no need to add it again .
                   // So add it only for ExportIndicationRequestMessage
  
             PEGASUS_ASSERT(p != 0);                  if (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE)
                   {
             nameSpace = p->nameSpace.getString();                      ProviderIdContainer pidc = _getProviderIdContainer(request);
             className = p->className.getString();              request->operationContext.insert(pidc);
         }         }
  
         break;          response = _providerManagerRouter->processMessage(request);
     case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:      }
       else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
         {         {
             const CIMEnumerateClassesRequestMessage * p = dynamic_cast<const CIMEnumerateClassesRequestMessage *>(message);          // Handle CIMEnableModuleRequestMessage
           CIMEnableModuleRequestMessage * emReq =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<CIMEnableModuleRequestMessage*>(request);
  
             nameSpace = p->nameSpace.getString();          CIMInstance providerModule = emReq->providerModule;
             className = p->className.getString();  
         }  
  
         break;          try
     case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:  
         {         {
             const CIMEnumerateClassNamesRequestMessage * p = dynamic_cast<const CIMEnumerateClassNamesRequestMessage *>(message);              // Forward the request to the ProviderManager
               response = _providerManagerRouter->processMessage(request);
  
             PEGASUS_ASSERT(p != 0);              // If successful, update provider module status to OK
               // ATTN: Use CIMEnableModuleResponseMessage operationalStatus?
             nameSpace = p->nameSpace.getString();              CIMEnableModuleResponseMessage * emResp =
             className = p->className.getString();                  dynamic_cast<CIMEnableModuleResponseMessage*>(response);
               if (emResp->cimException.getCode() == CIM_ERR_SUCCESS)
               {
                   _updateProviderModuleStatus(
                       providerModule, _MODULE_STOPPED, _MODULE_OK);
         }         }
           }
         break;          catch (Exception& e)
     case CIM_CREATE_CLASS_REQUEST_MESSAGE:  
         {         {
             const CIMCreateClassRequestMessage * p = dynamic_cast<const CIMCreateClassRequestMessage *>(message);              // Get the OperationalStatus property from the provider module
               Array<Uint16> operationalStatus;
             PEGASUS_ASSERT(p != 0);              CIMValue itValue = emReq->providerModule.getProperty(
                   emReq->providerModule.findProperty("OperationalStatus"))
                       .getValue();
               itValue.get(operationalStatus);
  
             nameSpace = p->nameSpace.getString();              if (response != 0)
             //className = p->className.getString();              {
                   delete response;
         }         }
  
         break;              response = new CIMEnableModuleResponseMessage(
     case CIM_MODIFY_CLASS_REQUEST_MESSAGE:                  request->messageId,
                   CIMException(CIM_ERR_FAILED, e.getMessage()),
                   request->queueIds.copyAndPop(),
                   operationalStatus);
           }
       }
       else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
         {         {
             const CIMModifyClassRequestMessage * p = dynamic_cast<const CIMModifyClassRequestMessage *>(message);          // Handle CIMDisableModuleRequestMessage
           CIMDisableModuleRequestMessage * dmReq =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<CIMDisableModuleRequestMessage*>(request);
  
             nameSpace = p->nameSpace.getString();          CIMInstance providerModule = dmReq->providerModule;
             //className = p->className.getString();          Boolean updateModuleStatus = !dmReq->disableProviderOnly;
         }  
  
         break;          try
     case CIM_DELETE_CLASS_REQUEST_MESSAGE:  
         {         {
             const CIMDeleteClassRequestMessage * p = dynamic_cast<const CIMDeleteClassRequestMessage *>(message);              // Change module status from OK to STOPPING
               if (updateModuleStatus)
               {
                   _updateProviderModuleStatus(
                       providerModule, _MODULE_OK, _MODULE_STOPPING);
               }
  
             PEGASUS_ASSERT(p != 0);              // Forward the request to the ProviderManager
               response = _providerManagerRouter->processMessage(request);
  
             nameSpace = p->nameSpace.getString();              // Update provider module status based on success or failure
             className = p->className.getString();              if (updateModuleStatus)
               {
                   CIMDisableModuleResponseMessage * dmResp =
                       dynamic_cast<CIMDisableModuleResponseMessage*>(response);
                   if (dmResp->cimException.getCode() != CIM_ERR_SUCCESS)
                   {
                       // Disable operation failed.  Module not stopped.
                       _updateProviderModuleStatus(
                           providerModule, _MODULE_STOPPING, _MODULE_OK);
         }         }
                   else
         break;  
     case CIM_GET_INSTANCE_REQUEST_MESSAGE:  
         {         {
             const CIMGetInstanceRequestMessage * p = dynamic_cast<const CIMGetInstanceRequestMessage *>(message);                      // Disable may or may not have been successful,
                       // depending on whether there are outstanding requests.
             PEGASUS_ASSERT(p != 0);                      // Use last operationalStatus entry.
                       _updateProviderModuleStatus(
             nameSpace = p->nameSpace.getString();                          providerModule, _MODULE_STOPPING,
             //className = p->className.getString();                          dmResp->operationalStatus[
                               dmResp->operationalStatus.size()-1]);
         }         }
               }
         break;          }
     case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:          catch (Exception& e)
         {         {
             const CIMEnumerateInstancesRequestMessage * p = dynamic_cast<const CIMEnumerateInstancesRequestMessage *>(message);              // Get the OperationalStatus property from the provider module
               Array<Uint16> operationalStatus;
             PEGASUS_ASSERT(p != 0);              CIMValue itValue = dmReq->providerModule.getProperty(
                   dmReq->providerModule.findProperty("OperationalStatus"))
                       .getValue();
               itValue.get(operationalStatus);
  
             nameSpace = p->nameSpace.getString();              if (response != 0)
             className = p->className.getString();              {
                   delete response;
         }         }
  
         break;              response = new CIMDisableModuleResponseMessage(
     case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:                  request->messageId,
                   CIMException(CIM_ERR_FAILED, e.getMessage()),
                   request->queueIds.copyAndPop(),
                   operationalStatus);
           }
       }
       else
         {         {
             const CIMEnumerateInstanceNamesRequestMessage * p = dynamic_cast<const CIMEnumerateInstanceNamesRequestMessage *>(message);          response = _providerManagerRouter->processMessage(request);
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }         }
  
         break;      AsyncLegacyOperationResult * async_result =
     case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:          new AsyncLegacyOperationResult(
         {          async->getKey(),
             const CIMCreateInstanceRequestMessage * p = dynamic_cast<const CIMCreateInstanceRequestMessage *>(message);          async->getRouting(),
           op,
           response);
  
             PEGASUS_ASSERT(p != 0);      _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
  
             nameSpace = p->nameSpace.getString();      PEG_METHOD_EXIT();
             //className = p->className.getString();  
         }         }
  
         break;  void ProviderManagerService::unload_idle_providers(void)
     case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:  
         {         {
             const CIMModifyInstanceRequestMessage * p = dynamic_cast<const CIMModifyInstanceRequestMessage *>(message);      _providerManagerRouter->unload_idle_providers();
   }
  
             PEGASUS_ASSERT(p != 0);  ProviderIdContainer ProviderManagerService::_getProviderIdContainer(
       const CIMRequestMessage* message)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::_getProviderIdContainer");
  
             nameSpace = p->nameSpace.getString();      CIMInstance providerModule;
             //className = p->className.getString();      CIMInstance provider;
         }  
  
       switch (message->getType())
       {
       case CIM_GET_CLASS_REQUEST_MESSAGE:
       case CIM_DELETE_CLASS_REQUEST_MESSAGE:
       case CIM_CREATE_CLASS_REQUEST_MESSAGE:
       case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
       case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
       case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
       case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
       case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
       case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
       case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
           // The ProviderManagerService does not support class operations
           PEGASUS_ASSERT(0);
         break;         break;
   
       case CIM_GET_INSTANCE_REQUEST_MESSAGE:
     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
       case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
       case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
       case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
       case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
       case CIM_GET_PROPERTY_REQUEST_MESSAGE:
       case CIM_SET_PROPERTY_REQUEST_MESSAGE:
         {         {
             const CIMDeleteInstanceRequestMessage * p = dynamic_cast<const CIMDeleteInstanceRequestMessage *>(message);          // Look up instance provider
           const CIMOperationRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMOperationRequestMessage*>(message);
           _providerRegistrationManager->lookupInstanceProvider(
             nameSpace = p->nameSpace.getString();              request->nameSpace, request->className, provider, providerModule);
             //className = p->className.getString();          break;
         }         }
  
         break;  
     case CIM_EXEC_QUERY_REQUEST_MESSAGE:     case CIM_EXEC_QUERY_REQUEST_MESSAGE:
       {
           // Look up instance query provider
           const CIMOperationRequestMessage* request =
               dynamic_cast<const CIMOperationRequestMessage*>(message);
           Boolean hasNoQuery;
           _providerRegistrationManager->lookupInstanceProvider(
               request->nameSpace, request->className, provider, providerModule,
               0, &hasNoQuery);
           // We shouldn't have gotten this far if this isn't a query provider
           PEGASUS_ASSERT(!hasNoQuery);
         break;         break;
       }
   
     case CIM_ASSOCIATORS_REQUEST_MESSAGE:     case CIM_ASSOCIATORS_REQUEST_MESSAGE:
         {         {
             const CIMAssociatorsRequestMessage * p = dynamic_cast<const CIMAssociatorsRequestMessage *>(message);          // Look up association provider
           const CIMAssociatorsRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMAssociatorsRequestMessage*>(message);
           Array<CIMInstance> providerModules;
             nameSpace = p->nameSpace.getString();          Array<CIMInstance> providers;
             //className = p->className.getString();          _providerRegistrationManager->lookupAssociationProvider(
               request->nameSpace, request->assocClass,
               providers, providerModules);
           providerModule = providerModules[0];
           provider = providers[0];
           break;
         }         }
  
         break;  
     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
         {         {
             const CIMAssociatorNamesRequestMessage * p = dynamic_cast<const CIMAssociatorNamesRequestMessage *>(message);          // Look up association provider
           const CIMAssociatorNamesRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMAssociatorNamesRequestMessage*>(message);
           Array<CIMInstance> providerModules;
             nameSpace = p->nameSpace.getString();          Array<CIMInstance> providers;
             //className = p->className.getString();          _providerRegistrationManager->lookupAssociationProvider(
               request->nameSpace, request->assocClass,
               providers, providerModules);
           providerModule = providerModules[0];
           provider = providers[0];
           break;
         }         }
  
         break;  
     case CIM_REFERENCES_REQUEST_MESSAGE:     case CIM_REFERENCES_REQUEST_MESSAGE:
         {         {
             const CIMReferencesRequestMessage * p = dynamic_cast<const CIMReferencesRequestMessage *>(message);          // Look up association provider
           const CIMReferencesRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMReferencesRequestMessage*>(message);
           Array<CIMInstance> providerModules;
             nameSpace = p->nameSpace.getString();          Array<CIMInstance> providers;
             //className = p->className.getString();          _providerRegistrationManager->lookupAssociationProvider(
               request->nameSpace, request->resultClass,
               providers, providerModules);
           providerModule = providerModules[0];
           provider = providers[0];
           break;
         }         }
  
         break;  
     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
         {         {
             const CIMReferenceNamesRequestMessage * p = dynamic_cast<const CIMReferenceNamesRequestMessage *>(message);          // Look up association provider
           const CIMReferenceNamesRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMReferenceNamesRequestMessage*>(message);
           Array<CIMInstance> providerModules;
             nameSpace = p->nameSpace.getString();          Array<CIMInstance> providers;
             //className = p->className.getString();          _providerRegistrationManager->lookupAssociationProvider(
               request->nameSpace, request->resultClass,
               providers, providerModules);
           providerModule = providerModules[0];
           provider = providers[0];
           break;
         }         }
  
         break;      case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
     case CIM_GET_PROPERTY_REQUEST_MESSAGE:  
         {         {
             const CIMGetPropertyRequestMessage * p = dynamic_cast<const CIMGetPropertyRequestMessage *>(message);          // Look up method provider
           const CIMInvokeMethodRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMInvokeMethodRequestMessage*>(message);
           _providerRegistrationManager->lookupMethodProvider(
             nameSpace = p->nameSpace.getString();              request->nameSpace, request->className, request->methodName,
             //className = p->className.getString();              provider, providerModule);
           break;
         }         }
  
         break;      case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
     case CIM_SET_PROPERTY_REQUEST_MESSAGE:  
         {         {
             const CIMSetPropertyRequestMessage * p = dynamic_cast<const CIMSetPropertyRequestMessage *>(message);          const CIMExportIndicationRequestMessage* request =
               dynamic_cast<const CIMExportIndicationRequestMessage*>(message);
             PEGASUS_ASSERT(p != 0);          _providerRegistrationManager->lookupIndicationConsumer(
               request->destinationPath, provider, providerModule);
             nameSpace = p->nameSpace.getString();          break;
             //className = p->className.getString();  
         }         }
  
         break;      case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:
     case CIM_INVOKE_METHOD_REQUEST_MESSAGE:      case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:
       case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
       case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
       case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
         {         {
             const CIMInvokeMethodRequestMessage * p = dynamic_cast<const CIMInvokeMethodRequestMessage *>(message);          // Provider information is already in the message
           const CIMIndicationRequestMessage* request =
             PEGASUS_ASSERT(p != 0);              dynamic_cast<const CIMIndicationRequestMessage*>(message);
           providerModule = request->providerModule;
             nameSpace = p->nameSpace.getString();          provider = request->provider;
             //className = p->className.getString();          break;
         }         }
  
         break;  
     /*  
     case CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:     case CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
         {      case CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
             const CIMEnableIndicationsSubscriptionRequestMessage * p = dynamic_cast<const CIMEnableIndicationsRequestMessage *>(message);      case CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:
       case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
       case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
       case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
       case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
           // These messages are not handled by the ProviderManagerService
           PEGASUS_ASSERT(0);
           break;
  
             PEGASUS_ASSERT(p != 0);      case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
       case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
       case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
           // These messages are handled specially by the ProviderManagerService
           PEGASUS_ASSERT(0);
           break;
  
             nameSpace = p->nameSpace.getString();      case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
             className = p->className.getString();      {
           // Provider information is already in the message
           const CIMInitializeProviderRequestMessage* request =
               dynamic_cast<const CIMInitializeProviderRequestMessage*>(message);
           providerModule = request->providerModule;
           provider = request->provider;
           break;
         }         }
  
         break;      }
     case CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:  
         {  
             const CIMModifyIndicationsRequestMessage * p = dynamic_cast<const CIMModifyIndicationsRequestMessage *>(message);  
  
             PEGASUS_ASSERT(p != 0);      PEGASUS_ASSERT(!providerModule.isUninitialized());
       PEGASUS_ASSERT(!provider.isUninitialized());
  
             nameSpace = p->nameSpace.getString();      PEG_METHOD_EXIT();
             className = p->className.getString();      return ProviderIdContainer(providerModule, provider);
         }         }
  
         break;  // Updates the providerModule instance and the ProviderRegistrationManager
     case CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:  void ProviderManagerService::_updateProviderModuleStatus(
       CIMInstance& providerModule,
       Uint16 fromStatus,
       Uint16 toStatus)
         {         {
             const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::_updateProviderModuleStatus");
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }  
  
         break;      Array<Uint16> operationalStatus;
     */      String providerModuleName;
     default:  
         break;  
     }  
  
     ProviderName name(      Uint32 pos = providerModule.findProperty(CIMName("Name"));
         CIMObjectPath(String::EMPTY, nameSpace, className).toString(),      PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
         String::EMPTY,      providerModule.getProperty(pos).getValue().get(providerModuleName);
         String::EMPTY,  
         String::EMPTY,  
         0);  
  
     // find provider manager      //
     name = ProviderRegistrar().findProvider(name);      // get operational status
       //
       pos = providerModule.findProperty(CIMName("OperationalStatus"));
       PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
       CIMProperty operationalStatusProperty = providerModule.getProperty(pos);
       CIMValue operationalStatusValue = operationalStatusProperty.getValue();
  
     // find provider manager for provider interface      if (!operationalStatusValue.isNull())
     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)  
     {     {
         // DEBUG          operationalStatusValue.get(operationalStatus);
         CString s1 = name.getInterfaceName().getCString();      }
         const char * p1 = s1;  
   
         CString s2 = _providerManagers[i].getInterfaceName().getCString();  
         const char * p2 = s2;  
  
         if(String::equalNoCase(name.getInterfaceName(), _providerManagers[i].getInterfaceName()))      //
       // update module status
       //
       for (Uint32 i = operationalStatus.size(); i > 0; i--)
         {         {
             try          if (operationalStatus[i-1] == fromStatus)
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              operationalStatus.remove(i-1);
                     "ProviderManagerService::handleCimRequest() passing control to provider manager.");  
   
                 // forward request  
                 response = _providerManagers[i].getProviderManager().processMessage(request);  
             }             }
             catch(...)  
             {  
                 // ATTN: create response with error message  
             }             }
  
             break;      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."));
     }     }
  
     // preserve message key      operationalStatusProperty.setValue(CIMValue(operationalStatus));
     response->setKey(request->getKey());  
  
     // set HTTP method in response from request      PEG_METHOD_EXIT();
     response->setHttpMethod(request->getHttpMethod());  }
  
     AsyncLegacyOperationResult * async_result =  void ProviderManagerService::indicationCallback(
         new AsyncLegacyOperationResult(      CIMProcessIndicationRequestMessage* request)
         async->getKey(),  {
         async->getRouting(),      if (_indicationServiceQueueId == PEG_NOT_FOUND)
         op,      {
         response);          Array<Uint32> serviceIds;
  
     _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);          providerManagerService->find_services(
               PEGASUS_QUEUENAME_INDICATIONSERVICE, 0, 0, &serviceIds);
           PEGASUS_ASSERT(serviceIds.size() != 0);
  
     PEG_METHOD_EXIT();          _indicationServiceQueueId = serviceIds[0];
 } }
  
 void ProviderManagerService::unload_idle_providers(void)      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.18  
changed lines
  Added in v.1.41
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2