(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.60 and 1.64

version 1.60, 2004/10/25 18:26:00 version 1.64, 2005/02/25 21:44:17
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%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.
Line 6 
Line 6 
 // 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.; // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // 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 97 
Line 99 
  
     _unloadIdleProvidersBusy = 0;     _unloadIdleProvidersBusy = 0;
  
     // Determine whether Out-of-Process Provider support is enabled      _basicProviderManagerRouter = 0;
       _oopProviderManagerRouter = 0;
   
       // Determine which ProviderManagerRouter(s) to use
   
     ConfigManager* configManager = ConfigManager::getInstance();     ConfigManager* configManager = ConfigManager::getInstance();
     if (String::equal(      Boolean forceProviderProcesses = String::equal(
         configManager->getCurrentValue("enableProviderProcesses"), "true"))          configManager->getCurrentValue("forceProviderProcesses"), "true");
   
   #ifdef PEGASUS_DISABLE_PROV_USERCTXT
       if (forceProviderProcesses)
     {     {
         _providerManagerRouter =          _oopProviderManagerRouter =
             new OOPProviderManagerRouter(indicationCallback);             new OOPProviderManagerRouter(indicationCallback);
     }     }
     else     else
     {     {
         _providerManagerRouter =          _basicProviderManagerRouter =
             new BasicProviderManagerRouter(indicationCallback);             new BasicProviderManagerRouter(indicationCallback);
     }     }
   #else
       _oopProviderManagerRouter =
           new OOPProviderManagerRouter(indicationCallback);
   
       if (!forceProviderProcesses)
       {
           _basicProviderManagerRouter =
               new BasicProviderManagerRouter(indicationCallback);
       }
   #endif
 } }
  
 ProviderManagerService::~ProviderManagerService(void) ProviderManagerService::~ProviderManagerService(void)
 { {
     delete _providerManagerRouter;      delete _basicProviderManagerRouter;
       delete _oopProviderManagerRouter;
     providerManagerService=NULL;     providerManagerService=NULL;
 } }
  
Line 391 
Line 411 
             //             //
             // Forward the request to the appropriate ProviderManagerRouter             // Forward the request to the appropriate ProviderManagerRouter
             //             //
             response = _providerManagerRouter->processMessage(request);              response = _processMessage(request);
         }         }
     }     }
     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)     else if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
Line 405 
Line 425 
         try         try
         {         {
             // Forward the request to the ProviderManager             // Forward the request to the ProviderManager
             response = _providerManagerRouter->processMessage(request);              response = _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 459 
Line 479 
             }             }
  
             // Forward the request to the ProviderManager             // Forward the request to the ProviderManager
             response = _providerManagerRouter->processMessage(request);              response = _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 508 
Line 528 
     }     }
     else     else
     {     {
         response = _providerManagerRouter->processMessage(request);          response = _processMessage(request);
     }     }
  
     AsyncLegacyOperationResult * async_result =     AsyncLegacyOperationResult * async_result =
Line 582 
Line 602 
                 response.cimException = PEGASUS_CIM_EXCEPTION(code, message);                 response.cimException = PEGASUS_CIM_EXCEPTION(code, message);
 } }
  
   Message* ProviderManagerService::_processMessage(CIMRequestMessage* request)
   {
       Message* response = 0;
   
       if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) ||
           (request->getType() ==
               CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE) ||
           (request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE))
       {
           if (_basicProviderManagerRouter)
           {
               response = _basicProviderManagerRouter->processMessage(request);
           }
   
           if (_oopProviderManagerRouter)
           {
               // Note: These responses do not contain interesting data, so just
               // use the last one.
               if (response)
               {
                   delete response;
               }
   
               response = _oopProviderManagerRouter->processMessage(request);
           }
       }
       else
       {
           CIMInstance providerModule;
   
           if (request->getType() == CIM_ENABLE_MODULE_REQUEST_MESSAGE)
           {
               CIMEnableModuleRequestMessage* emReq =
                   dynamic_cast<CIMEnableModuleRequestMessage*>(request);
               providerModule = emReq->providerModule;
           }
           else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
           {
               CIMDisableModuleRequestMessage* dmReq =
                   dynamic_cast<CIMDisableModuleRequestMessage*>(request);
               providerModule = dmReq->providerModule;
           }
           else
           {
               ProviderIdContainer pidc =
                   request->operationContext.get(ProviderIdContainer::NAME);
               providerModule = pidc.getModule();
           }
   
           Uint16 userContext = 0;
           Uint32 pos = providerModule.findProperty(
               PEGASUS_PROPERTYNAME_MODULE_USERCONTEXT);
           if (pos != PEG_NOT_FOUND)
           {
               providerModule.getProperty(pos).getValue().get(userContext);
           }
   
           // Forward the request to the appropriate ProviderManagerRouter, based
           // on the CIM Server configuration and the UserContext setting.
   
           ConfigManager* configManager = ConfigManager::getInstance();
           Boolean forceProviderProcesses = String::equal(
               configManager->getCurrentValue("forceProviderProcesses"), "true");
   
           if (forceProviderProcesses
   #ifndef PEGASUS_DISABLE_PROV_USERCTXT
               || (userContext == PG_PROVMODULE_USERCTXT_REQUESTOR)
               || (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)
               || ((userContext == PG_PROVMODULE_USERCTXT_PRIVILEGED) &&
                   !System::isPrivilegedUser(System::getEffectiveUserName()))
   #endif
              )
           {
               response = _oopProviderManagerRouter->processMessage(request);
           }
           else
           {
               response = _basicProviderManagerRouter->processMessage(request);
           }
       }
   
       return response;
   }
   
 void ProviderManagerService::unloadIdleProviders() void ProviderManagerService::unloadIdleProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
Line 616 
Line 720 
         ProviderManagerService* myself =         ProviderManagerService* myself =
             reinterpret_cast<ProviderManagerService*>(arg);             reinterpret_cast<ProviderManagerService*>(arg);
  
           if (myself->_basicProviderManagerRouter)
           {
         try         try
         {         {
             myself->_providerManagerRouter->unloadIdleProviders();                  myself->_basicProviderManagerRouter->unloadIdleProviders();
         }         }
         catch (...)         catch (...)
         {         {
             // Ignore errors             // Ignore errors
             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                 "Unexpected exception in _unloadIdleProvidersHandler");                      "Unexpected exception from "
                           "BasicProviderManagerRouter::_unloadIdleProviders");
               }
           }
   
           if (myself->_oopProviderManagerRouter)
           {
               try
               {
                   myself->_oopProviderManagerRouter->unloadIdleProviders();
               }
               catch (...)
               {
                   // Ignore errors
                   PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                       "Unexpected exception from "
                           "OOPProviderManagerRouter::_unloadIdleProviders");
               }
         }         }
  
         myself->_unloadIdleProvidersBusy--;         myself->_unloadIdleProvidersBusy--;

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