(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.24.6.2

version 1.18, 2003/10/30 23:31:27 version 1.24.6.2, 2004/03/02 19:43:41
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)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 41 
Line 42 
 #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/Destroyer.h>
   #include <Pegasus/ProviderManager/OperationResponseHandler.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
Line 64 
Line 66 
  
     ProviderManagerContainer(const String & physicalName, const String & logicalName, const String & interfaceName) : _manager(0)     ProviderManagerContainer(const String & physicalName, const String & logicalName, const String & interfaceName) : _manager(0)
     {     {
         #if defined(PEGASUS_OS_TYPE_WINDOWS)          _physicalName=ProviderManager::_resolvePhysicalName(physicalName);
         _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;         _logicalName = logicalName;
  
Line 114 
Line 103 
         return(*this);         return(*this);
     }     }
  
     ProviderManager & getProviderManager(void)      ProviderManager *getProviderManager(void)
     {     {
         return(*_manager);          return _manager;
     }     }
  
     const String & getPhysicalName(void) const     const String & getPhysicalName(void) const
Line 144 
Line 133 
  
 }; };
  
 static Array<ProviderManagerContainer> _providerManagers;  static Array<ProviderManagerContainer*> _providerManagers;
 // END TEMP SECTION // END TEMP SECTION
  
 inline Boolean _isSupportedRequestType(const Message * message) inline Boolean _isSupportedRequestType(const Message * message)
Line 165 
Line 154 
     return(false);     return(false);
 } }
  
   ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
   CIMRepository* ProviderManagerService::_repository=NULL;
   
 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)
 { {
       providerManagerService=this;
       _repository=repository;
   
     SetProviderRegistrationManager(providerRegistrationManager);     SetProviderRegistrationManager(providerRegistrationManager);
  
     // ATTN: this section is a temporary solution to populate the list of enabled     // ATTN: this section is a temporary solution to populate the list of enabled
Line 189 
Line 187 
  
     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
     #if defined(PEGASUS_OS_OS400)     #if defined(PEGASUS_OS_OS400)
     _providerManagers.append(ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));      _providerManagers.append(
          new ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));
     #else     #else
     _providerManagers.append(ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));      _providerManagers.append(
          new ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));
     #endif     #endif
     #endif     #endif
  
     #if defined(ENABLE_CMPI_PROVIDER_MANAGER)     #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
     #if defined(PEGASUS_OS_OS400)     #if defined(PEGASUS_OS_OS400)
     _providerManagers.append(ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));      _providerManagers.append(
          new ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));
     #else     #else
     _providerManagers.append(ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));      _providerManagers.append(
          new ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));
     #endif     #endif
     #endif     #endif
     // END TEMP SECTION     // END TEMP SECTION
Line 207 
Line 209 
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
       providerManagerService=NULL;
 } }
  
 Boolean ProviderManagerService::messageOK(const Message * message) Boolean ProviderManagerService::messageOK(const Message * message)
Line 277 
Line 280 
     return;     return;
 } }
  
 /*  
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleServiceOperation(void * arg) throw()  
 {  
     // get the service from argument  
     ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);  
   
     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() PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()
 { {
Line 420 
Line 380 
     PEGASUS_ASSERT((request != 0) && (async != 0));     PEGASUS_ASSERT((request != 0) && (async != 0));
  
     Message * response = 0;     Message * response = 0;
       String ifc;
  
     // get namespace and class name from message      // get the responsible provider Manager
     String nameSpace;      ProviderManager * pm = locateProviderManager(message,ifc);
     String className;      if (pm) {
           response = pm->processMessage(request);
     switch(message->getType())      }
     {  
     case CIM_GET_CLASS_REQUEST_MESSAGE:      else for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {
         {         ProviderManagerContainer *pmc=_providerManagers[i];
             const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);         switch (message->getType()) {
          case CIM_ENABLE_MODULE_REQUEST_MESSAGE: {
             PEGASUS_ASSERT(p != 0);               CIMEnableModuleRequestMessage * request =
                   dynamic_cast<CIMEnableModuleRequestMessage*>(const_cast<Message*>(message));
             nameSpace = p->nameSpace.getString();               if (request->providerModule.getProperty(request->providerModule.findProperty
             className = p->className.getString();                   ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
         }               response=pmc->getProviderManager()->processMessage(request);
             }
         break;            break;
     case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:         case CIM_DISABLE_MODULE_REQUEST_MESSAGE: {
         {               CIMDisableModuleRequestMessage * request =
             const CIMEnumerateClassesRequestMessage * p = dynamic_cast<const CIMEnumerateClassesRequestMessage *>(message);                  dynamic_cast<CIMDisableModuleRequestMessage*>(const_cast<Message*>(message));
                if (request->providerModule.getProperty(request->providerModule.findProperty
             PEGASUS_ASSERT(p != 0);                   ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
                response=pmc->getProviderManager()->processMessage(request);
             nameSpace = p->nameSpace.getString();            }
             className = p->className.getString();            break;
         }         case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: {
             Message  *resp=pmc->getProviderManager()->processMessage(request);
         break;            if (resp) response=resp; }
     case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:  
         {  
             const CIMEnumerateClassNamesRequestMessage * p = dynamic_cast<const CIMEnumerateClassNamesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }  
   
         break;  
     case CIM_CREATE_CLASS_REQUEST_MESSAGE:  
         {  
             const CIMCreateClassRequestMessage * p = dynamic_cast<const CIMCreateClassRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_MODIFY_CLASS_REQUEST_MESSAGE:  
         {  
             const CIMModifyClassRequestMessage * p = dynamic_cast<const CIMModifyClassRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_DELETE_CLASS_REQUEST_MESSAGE:  
         {  
             const CIMDeleteClassRequestMessage * p = dynamic_cast<const CIMDeleteClassRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }  
   
         break;  
     case CIM_GET_INSTANCE_REQUEST_MESSAGE:  
         {  
             const CIMGetInstanceRequestMessage * p = dynamic_cast<const CIMGetInstanceRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:  
         {  
             const CIMEnumerateInstancesRequestMessage * p = dynamic_cast<const CIMEnumerateInstancesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }  
   
         break;  
     case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:  
         {  
             const CIMEnumerateInstanceNamesRequestMessage * p = dynamic_cast<const CIMEnumerateInstanceNamesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->className.getString();  
         }  
   
         break;  
     case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:  
         {  
             const CIMCreateInstanceRequestMessage * p = dynamic_cast<const CIMCreateInstanceRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:  
         {  
             const CIMModifyInstanceRequestMessage * p = dynamic_cast<const CIMModifyInstanceRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:  
         {  
             const CIMDeleteInstanceRequestMessage * p = dynamic_cast<const CIMDeleteInstanceRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_EXEC_QUERY_REQUEST_MESSAGE:  
         break;  
     case CIM_ASSOCIATORS_REQUEST_MESSAGE:  
         {  
             const CIMAssociatorsRequestMessage * p = dynamic_cast<const CIMAssociatorsRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:  
         {  
             const CIMAssociatorNamesRequestMessage * p = dynamic_cast<const CIMAssociatorNamesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_REFERENCES_REQUEST_MESSAGE:  
         {  
             const CIMReferencesRequestMessage * p = dynamic_cast<const CIMReferencesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;         break;
     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:         default:
         {            CIMRequestMessage * req =
             const CIMReferenceNamesRequestMessage * p = dynamic_cast<const CIMReferenceNamesRequestMessage *>(message);                dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
             CIMResponseMessage  *resp=new CIMResponseMessage(0,req->messageId,CIMException(),
             PEGASUS_ASSERT(p != 0);               req->queueIds.copyAndPop());
             response=resp;
             nameSpace = p->nameSpace.getString();            resp->synch_response(req);
             //className = p->className.getString();            OperationResponseHandler handler(req, resp);
         }            handler.setStatus(CIM_ERR_FAILED, "Unknown messagetype.");
   
         break;  
     case CIM_GET_PROPERTY_REQUEST_MESSAGE:  
         {  
             const CIMGetPropertyRequestMessage * p = dynamic_cast<const CIMGetPropertyRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }  
   
         break;  
     case CIM_SET_PROPERTY_REQUEST_MESSAGE:  
         {  
             const CIMSetPropertyRequestMessage * p = dynamic_cast<const CIMSetPropertyRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }         }
   
         break;  
     case CIM_INVOKE_METHOD_REQUEST_MESSAGE:  
         {  
             const CIMInvokeMethodRequestMessage * p = dynamic_cast<const CIMInvokeMethodRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             //className = p->className.getString();  
         }         }
  
         break;      // preserve message key
     /*      response->setKey(request->getKey());
     case CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:  
         {  
             const CIMEnableIndicationsSubscriptionRequestMessage * p = dynamic_cast<const CIMEnableIndicationsRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
  
             nameSpace = p->nameSpace.getString();      // set HTTP method in response from request
             className = p->className.getString();      response->setHttpMethod(request->getHttpMethod());
         }  
  
         break;      AsyncLegacyOperationResult * async_result =
     case CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:          new AsyncLegacyOperationResult(
         {          async->getKey(),
             const CIMModifyIndicationsRequestMessage * p = dynamic_cast<const CIMModifyIndicationsRequestMessage *>(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;  ProviderManager* ProviderManagerService::locateProviderManager(const Message *message,
     case CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE:               String & it)
         {         {
             const CIMGetClassRequestMessage * p = dynamic_cast<const CIMGetClassRequestMessage *>(message);      CIMNamespaceName nameSpace;
       CIMName className;
             PEGASUS_ASSERT(p != 0);      CIMName method;
   
       const CIMOperationRequestMessage * p =
          dynamic_cast<const CIMOperationRequestMessage *>(message);
   
       if (p) {
          nameSpace=p->nameSpace;
   
          if (p->providerType==ProviderType::ASSOCIATION)
             className=((CIMAssociatorsRequestMessage*)p)->assocClass;
          else className=p->className;
   
          if (p->providerType==ProviderType::METHOD)
             method=((CIMInvokeMethodRequestMessage*)p)->methodName;
   
          ProviderName name(nameSpace,
              className,
              p->providerType,
              method);
  
             nameSpace = p->nameSpace.getString();         // find provider manager
             className = p->className.getString();         name = ProviderRegistrar().findProvider(name,false);
          it=name.getInterfaceName();
         }         }
  
         break;      else {
     */         const CIMIndicationRequestMessage * p =
             dynamic_cast<const CIMIndicationRequestMessage *>(message);
          if (p) {
             CIMIndicationRequestMessage *m=(CIMIndicationRequestMessage*)message;
             it=m->providerModule.getProperty (m->providerModule.findProperty
                   ("InterfaceType")).getValue ().toString ();
          }
   
          else switch (message->getType()) {
          case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
          case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
          case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
             return NULL;
     default:     default:
         break;            it="C++Default";
          }
     }     }
   
     ProviderName name(  
         CIMObjectPath(String::EMPTY, nameSpace, className).toString(),  
         String::EMPTY,  
         String::EMPTY,  
         String::EMPTY,  
         0);  
   
     // find provider manager  
     name = ProviderRegistrar().findProvider(name);  
  
     // find provider manager for provider interface     // find provider manager for provider interface
     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)
     {     {
         // DEBUG          if (String::equalNoCase(it,_providerManagers[i]->getInterfaceName())) {
         CString s1 = name.getInterfaceName().getCString();             ProviderManagerContainer *pmc=_providerManagers[i];
         const char * p1 = s1;             return pmc->getProviderManager();
   
         CString s2 = _providerManagers[i].getInterfaceName().getCString();  
         const char * p2 = s2;  
   
         if(String::equalNoCase(name.getInterfaceName(), _providerManagers[i].getInterfaceName()))  
         {  
             try  
             {  
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
                     "ProviderManagerService::handleCimRequest() passing control to provider manager.");  
   
                 // forward request  
                 response = _providerManagers[i].getProviderManager().processMessage(request);  
             }             }
             catch(...)  
             {  
                 // ATTN: create response with error message  
             }             }
       ProviderManagerContainer *pmc=_providerManagers[0];
             break;      return pmc->getProviderManager();
         }  
     }  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     // set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     AsyncLegacyOperationResult * async_result =  
         new AsyncLegacyOperationResult(  
         async->getKey(),  
         async->getRouting(),  
         op,  
         response);  
   
     _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);  
   
     PEG_METHOD_EXIT();  
 } }
  
 void ProviderManagerService::unload_idle_providers(void) void ProviderManagerService::unload_idle_providers(void)

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