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

Diff for /pegasus/src/Pegasus/ProviderManager2/Attic/OOPProviderManagerRouter.cpp between version 1.21 and 1.29

version 1.21, 2005/11/18 18:38:35 version 1.29, 2006/05/09 19:09:36
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // 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 8 
Line 8 
 // 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.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 96 
Line 98 
 public: public:
     OutstandingRequestEntry(     OutstandingRequestEntry(
         String messageId_,         String messageId_,
           CIMRequestMessage* requestMessage_,
         CIMResponseMessage*& responseMessage_,         CIMResponseMessage*& responseMessage_,
         Semaphore* responseReady_)         Semaphore* responseReady_)
         : messageId(messageId_),         : messageId(messageId_),
             requestMessage(requestMessage_),
           responseMessage(responseMessage_),           responseMessage(responseMessage_),
           responseReady(responseReady_)           responseReady(responseReady_)
     {     {
     }     }
  
     String messageId;     String messageId;
       CIMRequestMessage* requestMessage;
     CIMResponseMessage*& responseMessage;     CIMResponseMessage*& responseMessage;
     Semaphore* responseReady;     Semaphore* responseReady;
 }; };
Line 123 
Line 128 
     ProviderAgentContainer(     ProviderAgentContainer(
         const String & moduleName,         const String & moduleName,
         const String & userName,         const String & userName,
         PEGASUS_INDICATION_CALLBACK indicationCallback,          Uint16 userContext,
           PEGASUS_INDICATION_CALLBACK_T indicationCallback,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
           PEGASUS_PROVIDERMODULEFAIL_CALLBACK_T providerModuleFailCallback,
         Boolean subscriptionInitComplete);         Boolean subscriptionInitComplete);
  
     ~ProviderAgentContainer();     ~ProviderAgentContainer();
Line 175 
Line 183 
         with an error result.         with an error result.
  
         Note: The caller must lock the _agentMutex.         Note: The caller must lock the _agentMutex.
   
           @param cleanShutdown Indicates whether the provider agent process
           exited cleanly.  A value of true indicates that responses have been
           sent for all requests that have been processed.  A value of false
           indicates that one or more requests may have been partially processed.
        */
       void _uninitialize(Boolean cleanShutdown);
   
       /**
           Performs the processMessage work, but does not retry on a transient
           error.
      */      */
     void _uninitialize();      CIMResponseMessage* _processMessage(CIMRequestMessage* request);
  
     /**     /**
         Read and process response messages from the Provider Agent until         Read and process response messages from the Provider Agent until
Line 208 
Line 227 
     String _userName;     String _userName;
  
     /**     /**
           User Context setting of the provider module served by this Provider
           Agent.
        */
       Uint16 _userContext;
   
       /**
         Callback function to which all generated indications are sent for         Callback function to which all generated indications are sent for
         processing.         processing.
      */      */
     PEGASUS_INDICATION_CALLBACK _indicationCallback;      PEGASUS_INDICATION_CALLBACK_T _indicationCallback;
   
       /**
           Callback function to which response chunks are sent for processing.
        */
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T _responseChunkCallback;
   
       /**
           Callback function to be called upon detection of failure of a
           provider module.
        */
       PEGASUS_PROVIDERMODULEFAIL_CALLBACK_T _providerModuleFailCallback;
  
     /**     /**
         Indicates whether the Provider Agent is active.         Indicates whether the Provider Agent is active.
Line 275 
Line 311 
     static Uint32 _maxProviderProcesses;     static Uint32 _maxProviderProcesses;
  
     /**     /**
           A value indicating that a request message has not been processed.
           A CIMResponseMessage pointer with this value indicates that the
           corresponding CIMRequestMessage has not been processed.  This is
           used to indicate that a provider agent exited without starting to
           process the request, and that the request should be retried.
        */
       static CIMResponseMessage* _REQUEST_NOT_PROCESSED;
   
       /**
         Indicates whether the Indication Service has completed initialization.         Indicates whether the Indication Service has completed initialization.
  
         For more information, please see the description of the         For more information, please see the description of the
Line 287 
Line 332 
 Mutex ProviderAgentContainer::_numProviderProcessesMutex; Mutex ProviderAgentContainer::_numProviderProcessesMutex;
 Uint32 ProviderAgentContainer::_maxProviderProcesses = PEG_NOT_FOUND; Uint32 ProviderAgentContainer::_maxProviderProcesses = PEG_NOT_FOUND;
  
   // Set this to a value that no valid CIMResponseMessage* will have.
   CIMResponseMessage* ProviderAgentContainer::_REQUEST_NOT_PROCESSED =
       reinterpret_cast<CIMResponseMessage*>(&_REQUEST_NOT_PROCESSED);
   
 ProviderAgentContainer::ProviderAgentContainer( ProviderAgentContainer::ProviderAgentContainer(
     const String & moduleName,     const String & moduleName,
     const String & userName,     const String & userName,
     PEGASUS_INDICATION_CALLBACK indicationCallback,      Uint16 userContext,
       PEGASUS_INDICATION_CALLBACK_T indicationCallback,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
       PEGASUS_PROVIDERMODULEFAIL_CALLBACK_T providerModuleFailCallback,
     Boolean subscriptionInitComplete)     Boolean subscriptionInitComplete)
     : _moduleName(moduleName),     : _moduleName(moduleName),
       _userName(userName),       _userName(userName),
         _userContext(userContext),
       _indicationCallback(indicationCallback),       _indicationCallback(indicationCallback),
         _responseChunkCallback(responseChunkCallback),
         _providerModuleFailCallback(providerModuleFailCallback),
       _isInitialized(false),       _isInitialized(false),
       _subscriptionInitComplete(subscriptionInitComplete)       _subscriptionInitComplete(subscriptionInitComplete)
 { {
Line 483 
Line 538 
     }     }
 #elif defined (PEGASUS_OS_OS400) #elif defined (PEGASUS_OS_OS400)
  
     //Out of provider support for OS400 goes here when needed.      //Out of process provider support for OS400 goes here when needed.
  
 #else #else
   
   # ifndef PEGASUS_DISABLE_PROV_USERCTXT
       // Get and save the effective user name and the uid/gid for the user
       // context of the agent process
   
       String effectiveUserName = System::getEffectiveUserName();
       PEGASUS_UID_T newUid = (PEGASUS_UID_T) -1;
       PEGASUS_GID_T newGid = (PEGASUS_GID_T) -1;
       if (_userName != effectiveUserName)
       {
           if (!System::lookupUserId(_userName.getCString(), newUid, newGid))
           {
               throw PEGASUS_CIM_EXCEPTION_L(
                   CIM_ERR_FAILED,
                   MessageLoaderParms(
                       "ProviderManager.OOPProviderManagerRouter."
                           "USER_CONTEXT_CHANGE_FAILED",
                       "Unable to change user context to \"$0\".", _userName));
           }
       }
   # endif
   
     pid_t pid = fork();     pid_t pid = fork();
     if (pid < 0)     if (pid < 0)
     {     {
Line 523 
Line 600 
  
 #ifndef PEGASUS_DISABLE_PROV_USERCTXT #ifndef PEGASUS_DISABLE_PROV_USERCTXT
             // Set the user context of the Provider Agent process             // Set the user context of the Provider Agent process
             if (_userName != System::getEffectiveUserName())              if (_userName != effectiveUserName)
             {             {
                 if (!System::changeUserContext(_userName.getCString()))                  if (!System::changeUserContext(newUid, newGid))
                 {                 {
                     Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,                     Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                         "System::changeUserContext() failed.  userName = %s.",                         "System::changeUserContext() failed.  userName = %s.",
Line 635 
Line 712 
             _moduleName));             _moduleName));
     }     }
  
     // Do not wait for a response from the Provider Agent.  (It isn't coming.)      // Wait for a null response from the Provider Agent indicating it has
       // initialized successfully.
   
       CIMMessage* message;
       AnonymousPipe::Status readStatus;
       do
       {
           readStatus = _pipeFromAgent->readMessage(message);
       } while (readStatus == AnonymousPipe::STATUS_INTERRUPT);
   
       if (readStatus != AnonymousPipe::STATUS_SUCCESS)
       {
           PEG_METHOD_EXIT();
           throw Exception(MessageLoaderParms(
               "ProviderManager.OOPProviderManagerRouter."
                   "CIMPROVAGT_COMMUNICATION_FAILED",
               "Failed to communicate with cimprovagt \"$0\".",
               _moduleName));
       }
   
       PEGASUS_ASSERT(message == 0);
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 655 
Line 752 
  
     if (_maxProviderProcesses == PEG_NOT_FOUND)     if (_maxProviderProcesses == PEG_NOT_FOUND)
     {     {
         String maxProviderProcesses = ConfigManager::getInstance()->getCurrentValue("maxProviderProcesses");          String maxProviderProcesses = ConfigManager::getInstance()->
               getCurrentValue("maxProviderProcesses");
         CString maxProviderProcessesString = maxProviderProcesses.getCString();         CString maxProviderProcessesString = maxProviderProcesses.getCString();
         char* end = 0;         char* end = 0;
         _maxProviderProcesses = strtol(maxProviderProcessesString, &end, 10);         _maxProviderProcesses = strtol(maxProviderProcessesString, &end, 10);
Line 769 
Line 867 
 } }
  
 // Note: Caller must lock _agentMutex // Note: Caller must lock _agentMutex
 void ProviderAgentContainer::_uninitialize()  void ProviderAgentContainer::_uninitialize(Boolean cleanShutdown)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "ProviderAgentContainer::_uninitialize");         "ProviderAgentContainer::_uninitialize");
Line 825 
Line 923 
         {         {
             AutoMutex tableLock(_outstandingRequestTableMutex);             AutoMutex tableLock(_outstandingRequestTableMutex);
  
               CIMResponseMessage* response =
                   cleanShutdown ? _REQUEST_NOT_PROCESSED : 0;
   
             for (OutstandingRequestTable::Iterator i =             for (OutstandingRequestTable::Iterator i =
                      _outstandingRequestTable.start();                      _outstandingRequestTable.start();
                  i != 0; i++)                  i != 0; i++)
Line 832 
Line 933 
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                     String("Completing messageId \"") + i.value()->messageId +                     String("Completing messageId \"") + i.value()->messageId +
                         "\" with a null response.");                         "\" with a null response.");
                 i.value()->responseMessage = 0;                  i.value()->responseMessage = response;
                 i.value()->responseReady->signal();                 i.value()->responseReady->signal();
             }             }
  
             _outstandingRequestTable.clear();             _outstandingRequestTable.clear();
   
               //
               //  If not a clean shutdown, call the provider module failure
               //  callback
               //
               if (!cleanShutdown)
               {
                   //
                   //  Call the provider module failure callback to
                   //  communicate the failure to the Provider Manager Service
                   //  Provider Manager Service will inform Indication Service
                   //
                   _providerModuleFailCallback (_moduleName, _userName,
                       _userContext);
               }
         }         }
     }     }
     catch (...)     catch (...)
Line 861 
Line 977 
         "ProviderAgentContainer::processMessage");         "ProviderAgentContainer::processMessage");
  
     CIMResponseMessage* response;     CIMResponseMessage* response;
   
       do
       {
           response = _processMessage(request);
   
           if (response == _REQUEST_NOT_PROCESSED)
           {
               // Check for request message types that should not be retried.
               if ((request->getType() ==
                        CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) ||
                   (request->getType() ==
                        CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE) ||
                   (request->getType() ==
                        CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE) ||
                   (request->getType() ==
                        CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE))
               {
                   response = request->buildResponse();
                   break;
               }
               else if (request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE)
               {
                   CIMDisableModuleResponseMessage* dmResponse =
                       dynamic_cast<CIMDisableModuleResponseMessage*>(response);
                   PEGASUS_ASSERT(dmResponse != 0);
   
                   Array<Uint16> operationalStatus;
                   operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
                   dmResponse->operationalStatus = operationalStatus;
                   break;
               }
           }
       } while (response == _REQUEST_NOT_PROCESSED);
   
       PEG_METHOD_EXIT();
       return response;
   }
   
   CIMResponseMessage* ProviderAgentContainer::_processMessage(
       CIMRequestMessage* request)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "ProviderAgentContainer::_processMessage");
   
       CIMResponseMessage* response;
     String originalMessageId = request->messageId;     String originalMessageId = request->messageId;
  
     // These three variables are used for the provider module optimization.     // These three variables are used for the provider module optimization.
Line 887 
Line 1048 
         //         //
         Semaphore waitSemaphore(0);         Semaphore waitSemaphore(0);
         OutstandingRequestEntry outstandingRequestEntry(         OutstandingRequestEntry outstandingRequestEntry(
             uniqueMessageId, response, &waitSemaphore);              uniqueMessageId, request, response, &waitSemaphore);
  
         //         //
         // Lock the Provider Agent Container while initializing the         // Lock the Provider Agent Container while initializing the
Line 971 
Line 1132 
                     Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                     Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                         "Failed to write message to pipe.  writeStatus = %d.",                         "Failed to write message to pipe.  writeStatus = %d.",
                         writeStatus);                         writeStatus);
                     throw Exception(MessageLoaderParms(  
                         "ProviderManager.OOPProviderManagerRouter."                      request->messageId = originalMessageId;
                             "CIMPROVAGT_COMMUNICATION_FAILED",  
                         "Failed to communicate with cimprovagt \"$0\".",                      if (doProviderModuleOptimization)
                         _moduleName));                      {
                           request->operationContext.set(*origProviderId.get());
                       }
   
                       // Remove this OutstandingRequestTable entry
                       {
                           AutoMutex tableLock(_outstandingRequestTableMutex);
                           Boolean removed =
                               _outstandingRequestTable.remove(uniqueMessageId);
                           PEGASUS_ASSERT(removed);
                       }
   
                       // A response value of _REQUEST_NOT_PROCESSED indicates
                       // that the request was not processed by the provider
                       // agent, so it can be retried safely.
                       PEG_METHOD_EXIT();
                       return _REQUEST_NOT_PROCESSED;
                 }                 }
  
                 if (updateProviderModuleCache)                 if (updateProviderModuleCache)
Line 1001 
Line 1178 
                         _outstandingRequestTable.remove(uniqueMessageId);                         _outstandingRequestTable.remove(uniqueMessageId);
                     PEGASUS_ASSERT(removed);                     PEGASUS_ASSERT(removed);
                 }                 }
                   PEG_METHOD_EXIT();
                 throw;                 throw;
             }             }
         }         }
Line 1022 
Line 1200 
                     _outstandingRequestTable.remove(uniqueMessageId);                     _outstandingRequestTable.remove(uniqueMessageId);
                 PEGASUS_ASSERT(removed);                 PEGASUS_ASSERT(removed);
             }             }
               PEG_METHOD_EXIT();
             throw;             throw;
         }         }
  
           // A response value of _REQUEST_NOT_PROCESSED indicates that the
           // provider agent process was terminating when the request was sent.
           // The request was not processed by the provider agent, so it can be
           // retried safely.
           if (response == _REQUEST_NOT_PROCESSED)
           {
               PEG_METHOD_EXIT();
               return response;
           }
   
         // A null response is returned when an agent connection is closed         // A null response is returned when an agent connection is closed
         // while requests remain outstanding.         // while requests remain outstanding.
         if (response == 0)         if (response == 0)
Line 1117 
Line 1306 
                 (readStatus == AnonymousPipe::STATUS_CLOSED))                 (readStatus == AnonymousPipe::STATUS_CLOSED))
             {             {
                 AutoMutex lock(_agentMutex);                 AutoMutex lock(_agentMutex);
                 _uninitialize();                  _uninitialize(false);
                   return;
               }
   
               // A null message indicates that the provider agent process has
               // finished its processing and is ready to exit.
               if (message == 0)
               {
                   AutoMutex lock(_agentMutex);
                   _uninitialize(true);
                 return;                 return;
             }             }
  
Line 1128 
Line 1326 
                     reinterpret_cast<CIMProcessIndicationRequestMessage*>(                     reinterpret_cast<CIMProcessIndicationRequestMessage*>(
                         message));                         message));
             }             }
               else if (!message->isComplete())
               {
                   CIMResponseMessage* response;
                   response = dynamic_cast<CIMResponseMessage*>(message);
                   PEGASUS_ASSERT(response != 0);
   
                   // Get the OutstandingRequestEntry for this response chunk
                   OutstandingRequestEntry* _outstandingRequestEntry = 0;
                   {
                       AutoMutex tableLock(_outstandingRequestTableMutex);
                       Boolean foundEntry = _outstandingRequestTable.lookup(
                           response->messageId, _outstandingRequestEntry);
                       PEGASUS_ASSERT(foundEntry);
                   }
   
                   // Put the original message ID into the response
                   response->messageId =
                       _outstandingRequestEntry->requestMessage->messageId;
   
                   // Call the response chunk callback to process the chunk
                   _responseChunkCallback(
                       _outstandingRequestEntry->requestMessage, response);
               }
             else             else
             {             {
                 CIMResponseMessage* response;                 CIMResponseMessage* response;
Line 1182 
Line 1403 
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
  
 OOPProviderManagerRouter::OOPProviderManagerRouter( OOPProviderManagerRouter::OOPProviderManagerRouter(
     PEGASUS_INDICATION_CALLBACK indicationCallback)      PEGASUS_INDICATION_CALLBACK_T indicationCallback,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
       PEGASUS_PROVIDERMODULEFAIL_CALLBACK_T providerModuleFailCallback)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "OOPProviderManagerRouter::OOPProviderManagerRouter");         "OOPProviderManagerRouter::OOPProviderManagerRouter");
  
     _indicationCallback = indicationCallback;     _indicationCallback = indicationCallback;
       _responseChunkCallback = responseChunkCallback;
       _providerModuleFailCallback = providerModuleFailCallback;
     _subscriptionInitComplete = false;     _subscriptionInitComplete = false;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 1213 
Line 1438 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 // Private, unimplemented constructor  
 OOPProviderManagerRouter::OOPProviderManagerRouter()  
 {  
 }  
   
 // Private, unimplemented constructor  
 OOPProviderManagerRouter::OOPProviderManagerRouter(  
     const OOPProviderManagerRouter&)  
     : ProviderManagerRouter(*this)  
 {  
 }  
   
 // Private, unimplemented assignment operator  
 OOPProviderManagerRouter& OOPProviderManagerRouter::operator=(  
     const OOPProviderManagerRouter&)  
 {  
     return *this;  
 }  
   
 Message* OOPProviderManagerRouter::processMessage(Message* message) Message* OOPProviderManagerRouter::processMessage(Message* message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
Line 1464 
Line 1670 
     }     }
     else     else
     {     {
           //
           // Look up the Provider Agent for this module instance and requesting
           // user
           //
           ProviderAgentContainer* pa = _lookupProviderAgent(providerModule,
               request);
           PEGASUS_ASSERT(pa != 0);
   
           //
           // Forward the request to the provider agent
           //
           response.reset(pa->processMessage(request));
       }
   
       response->syncAttributes(request);
   
       PEG_METHOD_EXIT();
       return response.release();
   }
   
   ProviderAgentContainer* OOPProviderManagerRouter::_lookupProviderAgent(
       const CIMInstance& providerModule,
       CIMRequestMessage* request)
   {
         // Retrieve the provider module name         // Retrieve the provider module name
         String moduleName;         String moduleName;
         CIMValue nameValue = providerModule.getProperty(         CIMValue nameValue = providerModule.getProperty(
Line 1486 
Line 1716 
  
         if (userContext == 0)         if (userContext == 0)
         {         {
             userContext = PG_PROVMODULE_USERCTXT_PRIVILEGED;          userContext = PEGASUS_DEFAULT_PROV_USERCTXT;
         }         }
  
         String userName;         String userName;
Line 1500 
Line 1730 
                     request->operationContext.get(IdentityContainer::NAME);                     request->operationContext.get(IdentityContainer::NAME);
                 userName = ic.getUserName();                 userName = ic.getUserName();
             }             }
             catch (Exception& e)          catch (Exception&)
             {             {
                 // If no IdentityContainer is present, default to the CIM                 // If no IdentityContainer is present, default to the CIM
                 // Server's user context                 // Server's user context
Line 1514 
Line 1744 
         }         }
         else if (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)         else if (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)
         {         {
             // Retrieve the provider module name          // Retrieve the provider module designated user property value
             providerModule.getProperty(providerModule.findProperty(             providerModule.getProperty(providerModule.findProperty(
                 PEGASUS_PROPERTYNAME_MODULE_DESIGNATEDUSER)).getValue().                 PEGASUS_PROPERTYNAME_MODULE_DESIGNATEDUSER)).getValue().
                 get(userName);                 get(userName);
Line 1536 
Line 1766 
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "User name = " + userName);             "User name = " + userName);
  
         // Look up the Provider Agent for this module and user  
         ProviderAgentContainer* pa = _lookupProviderAgent(moduleName, userName);  
         PEGASUS_ASSERT(pa != 0);  
   
         //  
         // Forward the request to the provider agent  
         //  
         response.reset(pa->processMessage(request));  
     }  
   
     response->syncAttributes(request);  
   
     PEG_METHOD_EXIT();  
     return response.release();  
 }  
   
 ProviderAgentContainer* OOPProviderManagerRouter::_lookupProviderAgent(  
     const String& moduleName,  
     const String& userName)  
 {  
     ProviderAgentContainer* pa = 0;     ProviderAgentContainer* pa = 0;
     String key = moduleName + ":" + userName;     String key = moduleName + ":" + userName;
  
Line 1563 
Line 1773 
     if (!_providerAgentTable.lookup(key, pa))     if (!_providerAgentTable.lookup(key, pa))
     {     {
         pa = new ProviderAgentContainer(         pa = new ProviderAgentContainer(
             moduleName, userName, _indicationCallback,              moduleName, userName, userContext,
               _indicationCallback, _responseChunkCallback,
               _providerModuleFailCallback,
             _subscriptionInitComplete);             _subscriptionInitComplete);
         _providerAgentTable.insert(key, pa);         _providerAgentTable.insert(key, pa);
     }     }

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