(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.24 and 1.25.2.2

version 1.24, 2006/02/01 21:10:19 version 1.25.2.2, 2006/03/15 21:28:36
Line 98 
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 125 
Line 128 
     ProviderAgentContainer(     ProviderAgentContainer(
         const String & moduleName,         const String & moduleName,
         const String & userName,         const String & userName,
         PEGASUS_INDICATION_CALLBACK indicationCallback,          PEGASUS_INDICATION_CALLBACK_T indicationCallback,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
         Boolean subscriptionInitComplete);         Boolean subscriptionInitComplete);
  
     ~ProviderAgentContainer();     ~ProviderAgentContainer();
Line 224 
Line 228 
         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;
  
     /**     /**
         Indicates whether the Provider Agent is active.         Indicates whether the Provider Agent is active.
Line 316 
Line 325 
 ProviderAgentContainer::ProviderAgentContainer( ProviderAgentContainer::ProviderAgentContainer(
     const String & moduleName,     const String & moduleName,
     const String & userName,     const String & userName,
     PEGASUS_INDICATION_CALLBACK indicationCallback,      PEGASUS_INDICATION_CALLBACK_T indicationCallback,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
     Boolean subscriptionInitComplete)     Boolean subscriptionInitComplete)
     : _moduleName(moduleName),     : _moduleName(moduleName),
       _userName(userName),       _userName(userName),
       _indicationCallback(indicationCallback),       _indicationCallback(indicationCallback),
         _responseChunkCallback(responseChunkCallback),
       _isInitialized(false),       _isInitialized(false),
       _subscriptionInitComplete(subscriptionInitComplete)       _subscriptionInitComplete(subscriptionInitComplete)
 { {
Line 661 
Line 672 
             _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 681 
Line 712 
  
     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 849 
Line 881 
         // connection         // connection
         //         //
         {         {
               //
               //  If not a clean shutdown, log a warning message in case module
               //  included indication providers
               //
               if (!cleanShutdown)
               {
                   Logger::put_l(
                       Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                       "ProviderManager.OOPProviderManagerRouter."
                           "OOP_PROVIDER_MODULE_FAILURE_DETECTED",
                       "A failure was detected in provider module $0.  The"
                           " generation of indications by providers in this module"
                           " may be affected.  To ensure these providers are"
                           " serving active subscriptions, disable and then"
                           " re-enable this module using the cimprovider command.",
                       _moduleName);
               }
   
             AutoMutex tableLock(_outstandingRequestTableMutex);             AutoMutex tableLock(_outstandingRequestTableMutex);
  
             CIMResponseMessage* response =             CIMResponseMessage* response =
Line 894 
Line 944 
     do     do
     {     {
         response = _processMessage(request);         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);     } while (response == _REQUEST_NOT_PROCESSED);
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 933 
Line 1011 
         //         //
         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 1017 
Line 1095 
                     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 1047 
Line 1141 
                         _outstandingRequestTable.remove(uniqueMessageId);                         _outstandingRequestTable.remove(uniqueMessageId);
                     PEGASUS_ASSERT(removed);                     PEGASUS_ASSERT(removed);
                 }                 }
                   PEG_METHOD_EXIT();
                 throw;                 throw;
             }             }
         }         }
Line 1068 
Line 1163 
                     _outstandingRequestTable.remove(uniqueMessageId);                     _outstandingRequestTable.remove(uniqueMessageId);
                 PEGASUS_ASSERT(removed);                 PEGASUS_ASSERT(removed);
             }             }
               PEG_METHOD_EXIT();
             throw;             throw;
         }         }
  
Line 1077 
Line 1173 
         // retried safely.         // retried safely.
         if (response == _REQUEST_NOT_PROCESSED)         if (response == _REQUEST_NOT_PROCESSED)
         {         {
               PEG_METHOD_EXIT();
             return response;             return response;
         }         }
  
Line 1192 
Line 1289 
                     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 1246 
Line 1366 
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
  
 OOPProviderManagerRouter::OOPProviderManagerRouter( OOPProviderManagerRouter::OOPProviderManagerRouter(
     PEGASUS_INDICATION_CALLBACK indicationCallback)      PEGASUS_INDICATION_CALLBACK_T indicationCallback,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "OOPProviderManagerRouter::OOPProviderManagerRouter");         "OOPProviderManagerRouter::OOPProviderManagerRouter");
  
     _indicationCallback = indicationCallback;     _indicationCallback = indicationCallback;
       _responseChunkCallback = responseChunkCallback;
     _subscriptionInitComplete = false;     _subscriptionInitComplete = false;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 1608 
Line 1730 
     if (!_providerAgentTable.lookup(key, pa))     if (!_providerAgentTable.lookup(key, pa))
     {     {
         pa = new ProviderAgentContainer(         pa = new ProviderAgentContainer(
             moduleName, userName, _indicationCallback,              moduleName, userName, _indicationCallback, _responseChunkCallback,
             _subscriptionInitComplete);             _subscriptionInitComplete);
         _providerAgentTable.insert(key, pa);         _providerAgentTable.insert(key, pa);
     }     }

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