(file) Return to BasicProviderManagerRouter.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Attic

Diff for /pegasus/src/Pegasus/ProviderManager2/Attic/BasicProviderManagerRouter.cpp between version 1.2 and 1.16

version 1.2, 2004/05/21 22:01:53 version 1.16, 2005/02/06 21:23:07
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., 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.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software 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 26 
Line 30 
 // Author: Chip Vincent (cvincent@us.ibm.com) // Author: Chip Vincent (cvincent@us.ibm.com)
 //         Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //         Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 // Modified By:  // Modified By: Seema Gupta(gseema@in.ibm.com) for PEP135
   //              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "BasicProviderManagerRouter.h" #include "BasicProviderManagerRouter.h"
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/OperationContextInternal.h>
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/FileSystem.h>
   #include <Pegasus/Config/ConfigManager.h>
 #include <Pegasus/ProviderManager2/OperationResponseHandler.h> #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
 #include <Pegasus/ProviderManager2/ProviderManagerModule.h> #include <Pegasus/ProviderManager2/ProviderManagerModule.h>
 #include <Pegasus/ProviderManager2/ProviderManager.h> #include <Pegasus/ProviderManager2/ProviderManager.h>
Line 74 
Line 82 
         PEGASUS_INDICATION_CALLBACK indicationCallback)         PEGASUS_INDICATION_CALLBACK indicationCallback)
     : _manager(0)     : _manager(0)
     {     {
         _physicalName = ProviderManager::_resolvePhysicalName(physicalName);  #if defined (PEGASUS_OS_VMS)
           _physicalName = FileSystem::buildLibraryFileName(physicalName);
   #else
           _physicalName = ConfigManager::getHomedPath(PEGASUS_DEST_LIB_DIR) +
               String("/") + FileSystem::buildLibraryFileName(physicalName);
   #endif
  
         _logicalName = logicalName;         _logicalName = logicalName;
         _interfaceName = interfaceName;         _interfaceName = interfaceName;
Line 176 
Line 189 
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     Message* response = 0;     Message* response = 0;
       Boolean remoteNameSpaceRequest=false;
  
     //     //
     // Retrieve the ProviderManager routing information     // Retrieve the ProviderManager routing information
Line 184 
Line 198 
     CIMInstance providerModule;     CIMInstance providerModule;
  
     if ((dynamic_cast<CIMOperationRequestMessage*>(request) != 0) ||     if ((dynamic_cast<CIMOperationRequestMessage*>(request) != 0) ||
         (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE))          (request->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE) ||
           (request->getType() == CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE))
     {     {
         // Provider information is in OperationContext         // Provider information is in OperationContext
         ProviderIdContainer pidc = (ProviderIdContainer)         ProviderIdContainer pidc = (ProviderIdContainer)
             request->operationContext.get(ProviderIdContainer::NAME);             request->operationContext.get(ProviderIdContainer::NAME);
         providerModule = pidc.getModule();         providerModule = pidc.getModule();
           remoteNameSpaceRequest=pidc.isRemoteNameSpace();
     }     }
     else if (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0)     else if (dynamic_cast<CIMIndicationRequestMessage*>(request) != 0)
     {     {
         // Provider information is in CIMIndicationRequestMessage         // Provider information is in CIMIndicationRequestMessage
         CIMIndicationRequestMessage* indReq =         CIMIndicationRequestMessage* indReq =
             dynamic_cast<CIMIndicationRequestMessage*>(request);             dynamic_cast<CIMIndicationRequestMessage*>(request);
         providerModule = indReq->providerModule;                  ProviderIdContainer pidc = indReq->operationContext.get(ProviderIdContainer::NAME);
           providerModule = pidc.getModule();
     }     }
     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
     {     {
Line 212 
Line 229 
             dynamic_cast<CIMDisableModuleRequestMessage*>(request);             dynamic_cast<CIMDisableModuleRequestMessage*>(request);
         providerModule = dmReq->providerModule;         providerModule = dmReq->providerModule;
     }     }
     else if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)      else if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) ||
                (request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE))
     {     {
         // This operation is not provider-specific         // This operation is not provider-specific
     }     }
     else if (dynamic_cast<CIMInitializeProviderRequestMessage*>(request) != 0)  
     {  
         // Provider information is in CIMInitializeProviderRequestMessage  
         CIMInitializeProviderRequestMessage* initReq =  
             dynamic_cast<CIMInitializeProviderRequestMessage*>(request);  
         providerModule = initReq->providerModule;  
     }  
     else     else
     {     {
         // Error: Unrecognized message type.         // Error: Unrecognized message type.
         PEGASUS_ASSERT(0);         PEGASUS_ASSERT(0);
         CIMResponseMessage* resp = new CIMResponseMessage(          CIMResponseMessage* resp = request->buildResponse();
             0, request->messageId, CIMException(),          resp->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
             request->queueIds.copyAndPop());              "Unknown message type.");
         resp->synch_response(request);  
         OperationResponseHandler handler(request, resp);  
         handler.setStatus(CIM_ERR_FAILED, "Unknown message type.");  
         response = resp;         response = resp;
     }     }
  
Line 243 
Line 251 
     if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)     if (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)
     {     {
         // Send CIMStopAllProvidersRequestMessage to all ProviderManagers         // Send CIMStopAllProvidersRequestMessage to all ProviderManagers
           ReadLock tableLock(_providerManagerTableLock);
         for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)         for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
         {         {
             ProviderManagerContainer* pmc=_providerManagerTable[i];             ProviderManagerContainer* pmc=_providerManagerTable[i];
             Message* resp = pmc->getProviderManager()->processMessage(request);             Message* resp = pmc->getProviderManager()->processMessage(request);
             if (resp)             if (resp)
             {             {
                 response = resp;                  delete resp;
             }             }
         }         }
   
           response = request->buildResponse();
       }
       else if(request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE)
       {
           // Do not need to forward this request to in-process provider
           // managers
           response = request->buildResponse();
     }     }
     else     else
     {     {
Line 263 
Line 280 
  
         // Look up the appropriate ProviderManager by InterfaceType         // Look up the appropriate ProviderManager by InterfaceType
         ProviderManager* pm = _lookupProviderManager(interfaceType);         ProviderManager* pm = _lookupProviderManager(interfaceType);
         response = pm->processMessage(request);          if (remoteNameSpaceRequest && !pm->supportsRemoteNameSpaces()) {
              CIMResponseMessage* resp = request->buildResponse();
              resp->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                  "Remote Namespace operations not supported for interface type "+interfaceType);
              response = resp;
           }
           else response = pm->processMessage(request);
     }     }
  
     // preserve message key     // preserve message key
Line 312 
Line 335 
         // another temporary solution for converting a generic file name into         // another temporary solution for converting a generic file name into
         // a file name useable by each platform.         // a file name useable by each platform.
  
 #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)  #if defined(PEGASUS_ENABLE_DEFAULT_PROVIDER_MANAGER)
         if (interfaceType == "C++Default")         if (interfaceType == "C++Default")
         {         {
             ProviderManagerContainer* pmc = new ProviderManagerContainer(             ProviderManagerContainer* pmc = new ProviderManagerContainer(
Line 323 
Line 346 
         }         }
 #endif #endif
  
 #if defined(ENABLE_CMPI_PROVIDER_MANAGER)  #if defined(PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER)
         if (interfaceType == "CMPI")         if (interfaceType == "CMPI")
         {         {
             ProviderManagerContainer* pmc = new ProviderManagerContainer(             ProviderManagerContainer* pmc = new ProviderManagerContainer(
Line 333 
Line 356 
         }         }
 #endif #endif
  
 #if defined(ENABLE_JMPI_PROVIDER_MANAGER)  #if defined(PEGASUS_ENABLE_JMPI_PROVIDER_MANAGER)
         if (interfaceType == "JMPI")         if (interfaceType == "JMPI")
         {         {
             ProviderManagerContainer* pmc = new ProviderManagerContainer(             ProviderManagerContainer* pmc = new ProviderManagerContainer(
Line 351 
Line 374 
     return 0;     return 0;
 } }
  
 void BasicProviderManagerRouter::unload_idle_providers(void)  Boolean BasicProviderManagerRouter::hasActiveProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "BasicProviderManagerRouter::unload_idle_providers");          "BasicProviderManagerRouter::hasActiveProviders");
  
       ReadLock tableLock(_providerManagerTableLock);
     for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)     for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
     {     {
         ProviderManagerContainer* pmc = _providerManagerTable[i];         ProviderManagerContainer* pmc = _providerManagerTable[i];
         pmc->getProviderManager()->unload_idle_providers();          if (pmc->getProviderManager()->hasActiveProviders())
           {
               PEG_METHOD_EXIT();
               return true;
           }
       }
   
       PEG_METHOD_EXIT();
       return false;
   }
   
   void BasicProviderManagerRouter::unloadIdleProviders()
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "BasicProviderManagerRouter::unloadIdleProviders");
   
       //
       // Save pointers to the ProviderManagerContainers so we don't hold the
       // _providerManagerTableLock while unloading idle providers
       //
       Array<ProviderManagerContainer*> pmcs;
       {
           ReadLock tableLock(_providerManagerTableLock);
           for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
           {
               pmcs.append(_providerManagerTable[i]);
           }
       }
   
       //
       // Unload idle providers in each of the active ProviderManagers
       // _providerManagerTableLock while unloading idle providers
       //
       for (Uint32 i = 0; i < pmcs.size(); i++)
       {
           pmcs[i]->getProviderManager()->unloadIdleProviders();
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();

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