(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.19 and 1.24.6.4

version 1.19, 2003/10/31 14:43:40 version 1.24.6.4, 2004/03/24 00:50:34
Line 42 
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/ProviderManager2/OperationResponseHandler.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
Line 65 
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 167 
Line 155 
 } }
  
 ProviderManagerService* ProviderManagerService::providerManagerService=NULL; ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
   CIMRepository* ProviderManagerService::_repository=NULL;
  
 ProviderManagerService::ProviderManagerService(void) ProviderManagerService::ProviderManagerService(void)
     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
Line 174 
Line 163 
     providerManagerService=this;     providerManagerService=this;
 } }
  
 ProviderManagerService::ProviderManagerService(ProviderRegistrationManager * providerRegistrationManager)  ProviderManagerService::ProviderManagerService(
           ProviderRegistrationManager * providerRegistrationManager,
           CIMRepository * repository)
     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)     : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
 { {
     providerManagerService=this;     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 287 
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 430 
Line 380 
     PEGASUS_ASSERT((request != 0) && (async != 0));     PEGASUS_ASSERT((request != 0) && (async != 0));
  
     Message * response = 0;     Message * response = 0;
       String ifc;
  
     // get the responsible provider Manager     // get the responsible provider Manager
     ProviderManager *pm=locateProviderManager(message);      ProviderManager * pm = locateProviderManager(message,ifc);
       if (pm) {       if (pm) {
        response = pm->processMessage(request);        response = pm->processMessage(request);
     }     }
     else {  
        // no provider manager found ...      else for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {
          ProviderManagerContainer *pmc=_providerManagers[i];
          switch (message->getType()) {
          case CIM_ENABLE_MODULE_REQUEST_MESSAGE: {
                CIMEnableModuleRequestMessage * request =
                   dynamic_cast<CIMEnableModuleRequestMessage*>(const_cast<Message*>(message));
                if (request->providerModule.getProperty(request->providerModule.findProperty
                    ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
                response=pmc->getProviderManager()->processMessage(request);
             }
             break;
          case CIM_DISABLE_MODULE_REQUEST_MESSAGE: {
                CIMDisableModuleRequestMessage * request =
                   dynamic_cast<CIMDisableModuleRequestMessage*>(const_cast<Message*>(message));
                if (request->providerModule.getProperty(request->providerModule.findProperty
                    ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
                response=pmc->getProviderManager()->processMessage(request);
             }
             break;
          case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: {
             Message  *resp=pmc->getProviderManager()->processMessage(request);
             if (resp) response=resp; }
             break;
          default:
             CIMRequestMessage * req =
                 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
             CIMResponseMessage  *resp=new CIMResponseMessage(0,req->messageId,CIMException(),
                req->queueIds.copyAndPop());
             response=resp;
             resp->synch_response(req);
             OperationResponseHandler handler(req, resp);
             handler.setStatus(CIM_ERR_FAILED, "Unknown messagetype.");
          }
     }     }
  
     // preserve message key     // preserve message key
Line 458 
Line 441 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 ProviderManager* ProviderManagerService::locateProviderManager(const Message *message)  ProviderManager* ProviderManagerService::locateProviderManager(const Message *message,
 {               String & it)
     String nameSpace;  
     String className;  
     Uint32 type=ProviderType::INSTANCE;  
   
     switch(message->getType())  
     {  
     case CIM_GET_INSTANCE_REQUEST_MESSAGE:  
         {  
             const CIMGetInstanceRequestMessage * p = dynamic_cast<const CIMGetInstanceRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->instanceName.getClassName();  
         }  
   
         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);      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->newInstance.getClassName();         name = ProviderRegistrar().findProvider(name,false);
         }         it=name.getInterfaceName();
   
         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->modifiedInstance.getClassName();  
         }  
   
         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->instanceName.getClassName();  
         }  
   
         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->assocClass.getString();  
             type=ProviderType::ASSOCIATION;  
         }  
   
         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->assocClass.getString();  
             std::cout<<"--- className: "<<className<<std::endl;  
             type=ProviderType::ASSOCIATION;  
         }  
   
         break;  
     case CIM_REFERENCES_REQUEST_MESSAGE:  
         {  
             const CIMReferencesRequestMessage * p = dynamic_cast<const CIMReferencesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->resultClass.getString();  
             type=ProviderType::ASSOCIATION;  
        }  
   
         break;  
     case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:  
         {  
             const CIMReferenceNamesRequestMessage * p = dynamic_cast<const CIMReferenceNamesRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             className = p->resultClass.getString();  
             type=ProviderType::ASSOCIATION;  
        }  
   
         break;  
    case CIM_INVOKE_METHOD_REQUEST_MESSAGE:  
         {  
             const CIMInvokeMethodRequestMessage * p = dynamic_cast<const CIMInvokeMethodRequestMessage *>(message);  
   
             PEGASUS_ASSERT(p != 0);  
   
             nameSpace = p->nameSpace.getString();  
             type=ProviderType::METHOD;  
         }         }
  
         break;      else {
          const CIMIndicationRequestMessage * p =
      case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:            dynamic_cast<const CIMIndicationRequestMessage *>(message);
         {         if (p) {
             const CIMCreateSubscriptionRequestMessage * p = dynamic_cast<const CIMCreateSubscriptionRequestMessage *>(message);            CIMIndicationRequestMessage *m=(CIMIndicationRequestMessage*)message;
             it=m->providerModule.getProperty (m->providerModule.findProperty
             PEGASUS_ASSERT(p != 0);                  ("InterfaceType")).getValue ().toString ();
             nameSpace = p->nameSpace.getString();  
             std::cout<<"--- nameSpace: "<<nameSpace<<std::endl;  
             className = p->classNames[0].getString();  
             std::cout<<"--- className: "<<className<<std::endl;  
             type=ProviderType::INDICATION;  
         }         }
  
         break;         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:
         asm("int $3");            it="C++Default";
         break;         }
     }     }
   
     ProviderName name(  
         CIMObjectPath(String::EMPTY, nameSpace, className).toString(),  
         String::EMPTY,  
         String::EMPTY,  
         String::EMPTY,  
         type);  
   
         std::cout<<"--- name: "<<name.toString()<<std::endl;  
   
     // find provider manager  
     name = ProviderRegistrar().findProvider(name);  
   
     std::cout<<"--- name.getInterfaceName(): "<<name.getInterfaceName()<<std::endl;  
  
     // 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++)
     {     {
         if (String::equalNoCase(name.getInterfaceName(), _providerManagers[i]->getInterfaceName())) {          if (String::equalNoCase(it,_providerManagers[i]->getInterfaceName())) {
            ProviderManagerContainer *pmc=_providerManagers[i];            ProviderManagerContainer *pmc=_providerManagers[i];
            return pmc->getProviderManager();            return pmc->getProviderManager();
         }         }
     }     }
     return NULL;      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++)
       {
         ProviderManagerContainer *pmc=_providerManagers[i];
              pmc->getProviderManager()->unload_idle_providers();
       }
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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