(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.25 and 1.25.2.5

version 1.25, 2006/02/17 19:20:11 version 1.25.2.5, 2006/05/23 18:23:40
Line 97 
Line 97 
 { {
 public: public:
     OutstandingRequestEntry(     OutstandingRequestEntry(
         String messageId_,          String originalMessageId_,
           CIMRequestMessage* requestMessage_,
         CIMResponseMessage*& responseMessage_,         CIMResponseMessage*& responseMessage_,
         Semaphore* responseReady_)         Semaphore* responseReady_)
         : messageId(messageId_),          : originalMessageId(originalMessageId_),
             requestMessage(requestMessage_),
           responseMessage(responseMessage_),           responseMessage(responseMessage_),
           responseReady(responseReady_)           responseReady(responseReady_)
     {     {
     }     }
  
     String messageId;      /**
           A unique value is substituted as the request messageId attribute to
           allow responses to be definitively correllated with requests.
           The original messageId value is stored here to avoid a race condition
           between the processing of a response chunk and the resetting of the
           original messageId in the request message.
        */
       String originalMessageId;
       CIMRequestMessage* requestMessage;
     CIMResponseMessage*& responseMessage;     CIMResponseMessage*& responseMessage;
     Semaphore* responseReady;     Semaphore* responseReady;
 }; };
Line 125 
Line 135 
     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 221 
Line 234 
     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 316 
Line 346 
 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 509 
Line 545 
     }     }
 #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 549 
Line 607 
  
 #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 880 
Line 938 
                  i != 0; i++)                  i != 0; i++)
             {             {
                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                     String("Completing messageId \"") + i.value()->messageId +                      String("Completing messageId \"") + i.key() +
                         "\" with a null response.");                         "\" with a null response.");
                 i.value()->responseMessage = response;                 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 982 
Line 1055 
         //         //
         Semaphore waitSemaphore(0);         Semaphore waitSemaphore(0);
         OutstandingRequestEntry outstandingRequestEntry(         OutstandingRequestEntry outstandingRequestEntry(
             uniqueMessageId, response, &waitSemaphore);              originalMessageId, request, response, &waitSemaphore);
  
         //         //
         // Lock the Provider Agent Container while initializing the         // Lock the Provider Agent Container while initializing the
Line 1260 
Line 1333 
                     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->originalMessageId;
   
                   // Call the response chunk callback to process the chunk
                   _responseChunkCallback(
                       _outstandingRequestEntry->requestMessage, response);
               }
             else             else
             {             {
                 CIMResponseMessage* response;                 CIMResponseMessage* response;
Line 1314 
Line 1410 
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
  
 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 1577 
Line 1677 
     }     }
     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 1599 
Line 1723 
  
         if (userContext == 0)         if (userContext == 0)
         {         {
             userContext = PG_PROVMODULE_USERCTXT_PRIVILEGED;          userContext = PEGASUS_DEFAULT_PROV_USERCTXT;
         }         }
  
         String userName;         String userName;
Line 1613 
Line 1737 
                     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 1627 
Line 1751 
         }         }
         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 1649 
Line 1773 
         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 1676 
Line 1780 
     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.25  
changed lines
  Added in v.1.25.2.5
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2