(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.12 and 1.26

version 1.12, 2003/10/16 23:52:01 version 1.26, 2004/02/20 00:56:00
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC Corporation, The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 28 
Line 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 39 
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>
  
   #include <Pegasus/ProviderManager2/ProviderManagerModule.h>
   #include <Pegasus/ProviderManager2/ProviderManager.h>
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   // BEGIN TEMP SECTION
 class ProviderManagerContainer class ProviderManagerContainer
 { {
 public: public:
     ProviderManagerContainer(const String & name, const String & path) : _name(name), _module(path)      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();         _module.load();
  
         _manager = _module.getProviderManager(_name);          _manager = _module.getProviderManager(_logicalName);
   
           PEGASUS_ASSERT(_manager != 0);
     }     }
  
     ~ProviderManagerContainer(void)     ~ProviderManagerContainer(void)
Line 59 
Line 86 
         _module.unload();         _module.unload();
     }     }
  
     String & getName(void)      ProviderManagerContainer & operator=(const ProviderManagerContainer & container)
     {     {
         return(_name);          if(this == &container)
     }  
   
     ProviderManager & getProviderManager(void)  
     {     {
         return(*_manager);              return(*this);
     }     }
  
 private:          _logicalName = container._logicalName;
     String _name;          _physicalName = container._physicalName;
     ProviderManagerModule _module;          _interfaceName = container._interfaceName;
     ProviderManager * _manager;  
  
 };          _module = container._module;
           _manager = container._manager;
  
 static Array<ProviderManagerContainer> _providerManagers;          return(*this);
       }
  
 // BEGIN TEMP SECTION      ProviderManager *getProviderManager(void)
 class ProviderManagerRegistration  
 {  
 public:  
     ProviderManagerRegistration(const String & physicalName, const String & logicalName, const String & interfaceName)  
     {     {
         #if defined(PEGASUS_OS_TYPE_WINDOWS)          return _manager;
         _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") + physical + String(".sl"));  
         #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)  
         _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
         _physicalName.append(String("/lib") + physical + String(".so"));  
         #elif defined(PEGASUS_OS_OS400)  
         _physicalName = physicalName;  
         #else  
         _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
         _physicalName.append(String("/lib") + physical + String(".so"));  
         #endif  
   
         _logicalName = logicalName;  
   
         _interfaceName = interfaceName;  
     }     }
  
     const String & getPhysicalName(void) const     const String & getPhysicalName(void) const
Line 124 
Line 128 
     String _logicalName;     String _logicalName;
     String _interfaceName;     String _interfaceName;
  
       ProviderManagerModule _module;
       ProviderManager * _manager;
   
 }; };
   
   static Array<ProviderManagerContainer*> _providerManagers;
 // END TEMP SECTION // END TEMP SECTION
  
 inline Boolean _isSupportedRequestType(const Message * message) inline Boolean _isSupportedRequestType(const Message * message)
Line 145 
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 161 
Line 179 
     // each platform.     // each platform.
  
     // BEGIN TEMP SECTION     // BEGIN TEMP SECTION
     Array<ProviderManagerRegistration> registrations;  
   
     //#if defined(PEGASUS_OS_OS400)     //#if defined(PEGASUS_OS_OS400)
     //registrations.append(ProviderManagerRegistration("QSYS/??????????", "INTERNAL", "INTERNAL"));      //_providerManagers.append(ProviderManagerContainer("QSYS/??????????", "INTERNAL", "INTERNAL"));
     //#else     //#else
     //registrations.append(ProviderManagerRegistration("InternalProviderManager", "DEFAULT", "INTERNAL"));      //_providerManager.append(ProviderManagerContainer("InternalProviderManager", "DEFAULT", "INTERNAL"));
     //#endif     //#endif
  
     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)     #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
     #if defined(PEGASUS_OS_OS400)     #if defined(PEGASUS_OS_OS400)
     registrations.append(ProviderManagerRegistration("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));      _providerManagers.append(
          new ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));
     #else     #else
     registrations.append(ProviderManagerRegistration("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)
     registrations.append(ProviderManagerRegistration("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));      _providerManagers.append(
          new ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));
     #else     #else
     registrations.append(ProviderManagerRegistration("CMPIProviderManager", "CMPI", "CMPI"));      _providerManagers.append(
          new ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));
     #endif     #endif
     #endif     #endif
     // END TEMP SECTION     // END TEMP SECTION
   
     for(Uint32 i = 0, n = registrations.size(); i < n; i++)  
     {  
         try  
         {  
             ProviderManagerContainer container(registrations[i].getLogicalName(), registrations[i].getPhysicalName());  
   
             _providerManagers.append(container);  
         }  
         catch(...)  
         {  
         }  
     }  
 } }
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
       providerManagerService=NULL;
 } }
  
 Boolean ProviderManagerService::messageOK(const Message * message) Boolean ProviderManagerService::messageOK(const Message * message)
Line 272 
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 415 
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
       ProviderManager * pm = locateProviderManager(message,ifc);
     /*      if (pm) {
     ProviderName name(          response = pm->processMessage(request);
         String::EMPTY,      }
         String::EMPTY,  
         String::EMPTY,      else for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {
         String::EMPTY,                ProviderManagerContainer *pmc=_providerManagers[i];
         0);         switch (message->getType()) {
          case CIM_ENABLE_MODULE_REQUEST_MESSAGE: {
     // find provider manager               CIMEnableModuleRequestMessage * request =
     name = findProvider(name);                  dynamic_cast<CIMEnableModuleRequestMessage*>(const_cast<Message*>(message));
                if (request->providerModule.getProperty(request->providerModule.findProperty
     // find provider manager for provider interface                   ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
     */               response=pmc->getProviderManager()->processMessage(request);
              }
     try            break;
     {         case CIM_DISABLE_MODULE_REQUEST_MESSAGE: {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,               CIMDisableModuleRequestMessage * request =
             "ProviderManagerService::handleCimRequest() passing control to provider manager.");                  dynamic_cast<CIMDisableModuleRequestMessage*>(const_cast<Message*>(message));
                if (request->providerModule.getProperty(request->providerModule.findProperty
         // forward request                   ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
         response = _providerManagers[0].getProviderManager().processMessage(request);               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.");
     }     }
     catch(...)  
     {  
         // ATTN: create response with error message  
     }     }
  
     // preserve message key     // preserve message key
Line 463 
Line 441 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   ProviderManager* ProviderManagerService::locateProviderManager(const Message *message,
                String & it)
   {
       CIMNamespaceName nameSpace;
       CIMName className;
   
       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;
   
          ProviderName name(
              CIMObjectPath(String::EMPTY, nameSpace, className).toString(),
              String::EMPTY,
              String::EMPTY,
              String::EMPTY,
              p->providerType);
          // find provider manager
          name = ProviderRegistrar().findProvider(name,false);
          it=name.getInterfaceName();
       }
   
       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:
             it="C++Default";
          }
       }
   
       // find provider manager for provider interface
       for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)
       {
           if (String::equalNoCase(it,_providerManagers[i]->getInterfaceName())) {
              ProviderManagerContainer *pmc=_providerManagers[i];
              return pmc->getProviderManager();
           }
       }
       ProviderManagerContainer *pmc=_providerManagers[0];
       return pmc->getProviderManager();
   }
   
 void ProviderManagerService::unload_idle_providers(void) void ProviderManagerService::unload_idle_providers(void)
 { {
 } }

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