(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.38 and 1.39

version 1.38, 2004/05/17 23:42:58 version 1.39, 2004/05/18 23:58:41
Line 32 
Line 32 
 //              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) //              Adrian Schuur, IBM (schuur@de.ibm.com)
 //              Amit K Arora (amita@in.ibm.com) for PEP-101 //              Amit K Arora (amita@in.ibm.com) for PEP-101
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 40 
Line 41 
 #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/AutoPtr.h> #include <Pegasus/Common/AutoPtr.h>
 #include <Pegasus/ProviderManager2/OperationResponseHandler.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>  
 #include <Pegasus/ProviderManager2/ProviderType.h>  
 #include <Pegasus/ProviderManager2/ProviderName.h>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 58 
Line 56 
 static const Uint16 _MODULE_STOPPING = 9; static const Uint16 _MODULE_STOPPING = 9;
 static const Uint16 _MODULE_STOPPED  = 10; static const Uint16 _MODULE_STOPPED  = 10;
  
 // BEGIN TEMP SECTION  
 class ProviderManagerContainer  
 {  
 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)  
     {  
         _physicalName=ProviderManager::_resolvePhysicalName(physicalName);  
   
         _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)
 { {
     // ATTN: needs implementation     // ATTN: needs implementation
Line 163 
Line 76 
  
 ProviderManagerService* ProviderManagerService::providerManagerService=NULL; ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
 CIMRepository* ProviderManagerService::_repository=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)
Line 179 
Line 93 
     _repository=repository;     _repository=repository;
  
     _providerRegistrationManager = providerRegistrationManager;     _providerRegistrationManager = providerRegistrationManager;
       _providerManagerRouter =
     // ATTN: this section is a temporary solution to populate the list of enabled          new BasicProviderManagerRouter(indicationCallback);
     // 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  
     //#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(  
        new ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));  
     #else  
     _providerManagers.append(  
        new ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));  
     #endif  
     #endif  
   
     #if defined(ENABLE_CMPI_PROVIDER_MANAGER)  
     #if defined(PEGASUS_OS_OS400)  
     _providerManagers.append(  
        new ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));  
     #else  
     _providerManagers.append(  
        new ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));  
     #endif  
     #endif  
   
     #if defined(ENABLE_JMPI_PROVIDER_MANAGER)  
     #if defined(PEGASUS_OS_OS400)  
     _providerManagers.append(  
        new ProviderManagerContainer("QSYS/QYCMJMPIPM", "JMPI", "JMPI"));  
     #else  
     _providerManagers.append(  
        new ProviderManagerContainer("JMPIProviderManager", "JMPI", "JMPI"));  
     #endif  
     #endif  
   
     // END TEMP SECTION  
 } }
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
       delete _providerManagerRouter;
     providerManagerService=NULL;     providerManagerService=NULL;
 } }
  
Line 302 
Line 175 
     return;     return;
 } }
  
   PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()  ProviderManagerService::handleCimOperation(void * arg) throw()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimOperation");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::handleCimOperation");
  
     if(arg == 0)     if(arg == 0)
     {     {
Line 314 
Line 188 
     }     }
  
     // 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 331 
Line 207 
  
     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 343 
Line 220 
  
     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))
         {         {
Line 367 
Line 244 
  
             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 389 
Line 266 
     return(PEGASUS_THREAD_RETURN(0));     return(PEGASUS_THREAD_RETURN(0));
 } }
  
 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, Message * message)  void ProviderManagerService::handleCimRequest(
       AsyncOpNode * op,
       Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimRequest");      PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderManagerService::handleCimRequest");
  
     CIMRequestMessage * request = dynamic_cast<CIMRequestMessage *>(message);     CIMRequestMessage * request = dynamic_cast<CIMRequestMessage *>(message);
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
Line 412 
Line 292 
         ProviderIdContainer pidc = _getProviderIdContainer(request);         ProviderIdContainer pidc = _getProviderIdContainer(request);
         request->operationContext.insert(pidc);         request->operationContext.insert(pidc);
  
         // Retrieve the provider interface type          response = _providerManagerRouter->processMessage(request);
         String interfaceType;  
         CIMValue itValue = pidc.getModule().getProperty(  
             pidc.getModule().findProperty("InterfaceType")).getValue();  
         itValue.get(interfaceType);  
   
         // Forward the request to the appropriate ProviderManager  
         ProviderManager* pm = _lookupProviderManager(interfaceType);  
         response = pm->processMessage(request);  
     }  
     else if (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0)  
     {  
         // Handle CIMIndicationRequestMessage  
         CIMIndicationRequestMessage* indReq =  
             dynamic_cast<CIMIndicationRequestMessage*>(request);  
   
         // Get the InterfaceType property from the provider module instance  
         String interfaceType;  
         CIMValue itValue = indReq->providerModule.getProperty(  
             indReq->providerModule.findProperty("InterfaceType")).getValue();  
         itValue.get(interfaceType);  
   
         // Forward the request to the appropriate ProviderManager  
         ProviderManager* pm = _lookupProviderManager(interfaceType);  
         response = pm->processMessage(request);  
     }     }
     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
     {     {
Line 448 
Line 304 
  
         try         try
         {         {
             // Get the InterfaceType property from the provider module instance              // Forward the request to the ProviderManager
             String interfaceType;              response = _providerManagerRouter->processMessage(request);
             CIMValue itValue = emReq->providerModule.getProperty(  
                 emReq->providerModule.findProperty("InterfaceType")).getValue();  
             itValue.get(interfaceType);  
   
             // Forward the request to the appropriate ProviderManager  
             // ATTN: Why is this sent to a provider manager at all?  
             ProviderManager* pm = _lookupProviderManager(interfaceType);  
             response = pm->processMessage(request);  
  
             // If successful, update provider module status to OK             // If successful, update provider module status to OK
             // ATTN: Use CIMEnableModuleResponseMessage operationalStatus?             // ATTN: Use CIMEnableModuleResponseMessage operationalStatus?
Line 501 
Line 349 
  
         try         try
         {         {
             // Get the InterfaceType property from the provider module instance  
             String interfaceType;  
             CIMValue itValue = dmReq->providerModule.getProperty(  
                 dmReq->providerModule.findProperty("InterfaceType")).getValue();  
             itValue.get(interfaceType);  
   
             // Change module status from OK to STOPPING             // Change module status from OK to STOPPING
             if (updateModuleStatus)             if (updateModuleStatus)
             {             {
Line 514 
Line 356 
                     providerModule, _MODULE_OK, _MODULE_STOPPING);                     providerModule, _MODULE_OK, _MODULE_STOPPING);
             }             }
  
             // Forward the request to the appropriate ProviderManager              // Forward the request to the ProviderManager
             // ATTN: Why is this sent to a provider manager at all?              response = _providerManagerRouter->processMessage(request);
             ProviderManager* pm = _lookupProviderManager(interfaceType);  
             response = pm->processMessage(request);  
  
             // Update provider module status based on success or failure             // Update provider module status based on success or failure
             if (updateModuleStatus)             if (updateModuleStatus)
Line 563 
Line 403 
                 operationalStatus);                 operationalStatus);
         }         }
     }     }
     else if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)  
     {  
         // Handle CIMStopAllProvidersRequestMessage  
         // Send CIMStopAllProvidersRequestMessage to all ProviderManagers  
         for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++)  
         {  
             ProviderManagerContainer* pmc=_providerManagers[i];  
             Message* resp = pmc->getProviderManager()->processMessage(request);  
             if (resp)  
             {  
                 response = resp;  
             }  
         }  
     }  
     else     else
     {     {
         // ERROR: Unrecognized message type.          response = _providerManagerRouter->processMessage(request);
         PEGASUS_ASSERT(0);  
         CIMResponseMessage* resp = new CIMResponseMessage(  
             0, request->messageId, CIMException(),  
             request->queueIds.copyAndPop());  
         resp->synch_response(request);  
         OperationResponseHandler handler(request, resp);  
         handler.setStatus(CIM_ERR_FAILED, "Unknown message type.");  
         response = resp;  
     }     }
  
     // preserve message key  
     response->setKey(request->getKey());  
   
     // set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     AsyncLegacyOperationResult * async_result =     AsyncLegacyOperationResult * async_result =
         new AsyncLegacyOperationResult(         new AsyncLegacyOperationResult(
         async->getKey(),         async->getKey(),
Line 608 
Line 420 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 // ATTN: May need to add interfaceVersion parameter to further constrain lookup  
 ProviderManager* ProviderManagerService::_lookupProviderManager(  
     const String& interfaceType)  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,  
         "ProviderManagerService::_lookupProviderManager");  
   
     // find provider manager for specified provider interface type  
     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)  
     {  
         if (interfaceType == _providerManagers[i]->getInterfaceName())  
         {  
             ProviderManagerContainer* pmc=_providerManagers[i];  
             PEG_METHOD_EXIT();  
             return pmc->getProviderManager();  
         }  
     }  
   
     // ProviderManager not found for the specified interface type  
     PEGASUS_ASSERT(0);  
     PEG_METHOD_EXIT();  
     return 0;  
     //ProviderManagerContainer *pmc=_providerManagers[0];  
     //return pmc->getProviderManager();  
 }  
   
 void ProviderManagerService::unload_idle_providers(void) void ProviderManagerService::unload_idle_providers(void)
 { {
     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)      _providerManagerRouter->unload_idle_providers();
     {  
       ProviderManagerContainer *pmc=_providerManagers[i];  
            pmc->getProviderManager()->unload_idle_providers();  
     }  
 } }
  
 ProviderIdContainer ProviderManagerService::_getProviderIdContainer( ProviderIdContainer ProviderManagerService::_getProviderIdContainer(
Line 707 
Line 489 
         Array<CIMInstance> providerModules;         Array<CIMInstance> providerModules;
         Array<CIMInstance> providers;         Array<CIMInstance> providers;
         _providerRegistrationManager->lookupAssociationProvider(         _providerRegistrationManager->lookupAssociationProvider(
             request->nameSpace, request->assocClass, providers, providerModules);              request->nameSpace, request->assocClass,
               providers, providerModules);
         providerModule = providerModules[0];         providerModule = providerModules[0];
         provider = providers[0];         provider = providers[0];
         break;         break;
Line 721 
Line 504 
         Array<CIMInstance> providerModules;         Array<CIMInstance> providerModules;
         Array<CIMInstance> providers;         Array<CIMInstance> providers;
         _providerRegistrationManager->lookupAssociationProvider(         _providerRegistrationManager->lookupAssociationProvider(
             request->nameSpace, request->assocClass, providers, providerModules);              request->nameSpace, request->assocClass,
               providers, providerModules);
         providerModule = providerModules[0];         providerModule = providerModules[0];
         provider = providers[0];         provider = providers[0];
         break;         break;
Line 735 
Line 519 
         Array<CIMInstance> providerModules;         Array<CIMInstance> providerModules;
         Array<CIMInstance> providers;         Array<CIMInstance> providers;
         _providerRegistrationManager->lookupAssociationProvider(         _providerRegistrationManager->lookupAssociationProvider(
             request->nameSpace, request->resultClass, providers, providerModules);              request->nameSpace, request->resultClass,
               providers, providerModules);
         providerModule = providerModules[0];         providerModule = providerModules[0];
         provider = providers[0];         provider = providers[0];
         break;         break;
Line 749 
Line 534 
         Array<CIMInstance> providerModules;         Array<CIMInstance> providerModules;
         Array<CIMInstance> providers;         Array<CIMInstance> providers;
         _providerRegistrationManager->lookupAssociationProvider(         _providerRegistrationManager->lookupAssociationProvider(
             request->nameSpace, request->resultClass, providers, providerModules);              request->nameSpace, request->resultClass,
               providers, providerModules);
         providerModule = providerModules[0];         providerModule = providerModules[0];
         provider = providers[0];         provider = providers[0];
         break;         break;
Line 873 
Line 659 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   void ProviderManagerService::indicationCallback(
       CIMProcessIndicationRequestMessage* request)
   {
       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.38  
changed lines
  Added in v.1.39
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2