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

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIProviderManager.cpp between version 1.20 and 1.21

version 1.20, 2005/02/23 18:13:49 version 1.21, 2005/02/25 21:44:19
Line 71 
Line 71 
    mode=m;    mode=m;
    if (getenv("JMPI_TRACE")) _jmpi_trace=1;    if (getenv("JMPI_TRACE")) _jmpi_trace=1;
    else _jmpi_trace=0;    else _jmpi_trace=0;
      _subscriptionInitComplete = false;
 } }
  
 JMPIProviderManager::~JMPIProviderManager(void) JMPIProviderManager::~JMPIProviderManager(void)
Line 155 
Line 156 
         response = handleDeleteSubscriptionRequest(request);         response = handleDeleteSubscriptionRequest(request);
  
         break;         break;
     case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:  
         response = handleEnableIndicationsRequest(request);  
   
         break;  
     case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:  
         response = handleDisableIndicationsRequest(request);  
   
         break;  
 /*    case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: /*    case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
         response = handleExportIndicationRequest(request);         response = handleExportIndicationRequest(request);
         break;         break;
Line 183 
Line 176 
         response = handleInitializeProviderRequest(request);         response = handleInitializeProviderRequest(request);
  
         break;         break;
       case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
           response = handleSubscriptionInitCompleteRequest (request);
   
           break;
     default:     default:
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                 "*** Unsupported Request "+request->getType());                 "*** Unsupported Request "+request->getType());
Line 1683 
Line 1680 
            provTab.insert(providerName,prec);            provTab.insert(providerName,prec);
         }         }
  
           //
           //  Save the provider instance from the request
           //
           ph.GetProvider ().setProviderInstance (req_provider);
   
         indSelectRecord *srec=new indSelectRecord();         indSelectRecord *srec=new indSelectRecord();
         const CIMObjectPath &sPath=request->subscriptionInstance.getPath();         const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
         selxTab.insert(sPath.toString(),srec);         selxTab.insert(sPath.toString(),srec);
Line 1766 
Line 1768 
            jRef,(jboolean)0);            jRef,(jboolean)0);
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
           //
           //  Increment count of current subscriptions for this provider
           //
           if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())
           {
               //
               //  If there were no current subscriptions before the increment,
               //  the first subscription has been created
               //  Call the provider's enableIndications method
               //
               if (_subscriptionInitComplete)
               {
                   prec->enabled = true;
                   CIMRequestMessage * request = 0;
                   CIMResponseMessage * response = 0;
                   prec->handler = new EnableIndicationsResponseHandler
                       (request, response, req_provider, _indicationCallback);
               }
           }
   
        STAT_PMS_PROVIDEREND;        STAT_PMS_PROVIDEREND;
  
     }     }
Line 1866 
Line 1888 
            jRef,(jboolean)(prec==NULL));            jRef,(jboolean)(prec==NULL));
         JMPIjvm::checkException(env);         JMPIjvm::checkException(env);
  
        STAT_PMS_PROVIDEREND;          //
           //  Decrement count of current subscriptions for this provider
        delete eSelx;          //
           if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
     }  
     HandlerCatch(handler);  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * JMPIProviderManager::handleEnableIndicationsRequest(const Message * message) throw()  
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleEnableIndicationsRequest");              //
               //  If there are no current subscriptions after the decrement,
     HandlerIntroInd(EnableIndications,message,request,response,              //  the last subscription has been deleted
                  handler);              //  Call the provider's disableIndications method
     try {              //
         String providerName,providerLocation;              if (_subscriptionInitComplete)
                 CIMInstance req_provider, req_providerModule;              {
                 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);                  prec->enabled = false;
                 req_provider = pidc.getProvider();                  if (prec->handler) delete prec->handler;
                 req_providerModule = pidc.getModule();                  prec->handler = NULL;
   
         LocateIndicationProviderNames(req_provider, req_providerModule,  
            providerName,providerLocation);  
   
         indProvRecord *provRec;  
         if (provTab.lookup(providerName,provRec)) {  
            provRec->enabled=true;  
            provRec->handler=new EnableIndicationsResponseHandler(  
                request, response, req_provider, _indicationCallback);  
         }  
   
         String fileName = resolveFileName(providerLocation);  
   
         // get cached or load new provider module  
         JMPIProvider::OpProviderHolder ph =  
             providerManager.getProvider(fileName, providerName, String::EMPTY);  
   
     }     }
     HandlerCatch(handler);  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 } }
  
 Message * JMPIProviderManager::handleDisableIndicationsRequest(const Message * message) throw()         STAT_PMS_PROVIDEREND;
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleDisableIndicationsRequest");  
   
     HandlerIntroInd(DisableIndications,message,request,response,  
                  handler);  
     try {  
         String providerName,providerLocation;  
                 CIMInstance req_provider, req_providerModule;  
                 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);  
   
                 req_provider = pidc.getProvider();  
                 req_providerModule = pidc.getModule();  
   
         LocateIndicationProviderNames(req_provider, req_providerModule,  
            providerName,providerLocation);  
   
         indProvRecord *provRec;  
         if (provTab.lookup(providerName,provRec)) {  
            provRec->enabled=false;  
            if (provRec->handler) delete provRec->handler;  
            provRec->handler=NULL;  
         }  
  
         String fileName = resolveFileName(providerLocation);         delete eSelx;
  
         // get cached or load new provider module  
         JMPIProvider::OpProviderHolder ph =  
             providerManager.getProvider(fileName, providerName, String::EMPTY);  
     }     }
     HandlerCatch(handler);     HandlerCatch(handler);
  
Line 2092 
Line 2058 
     return(response);     return(response);
 } }
  
   Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest
       (const Message * message)
   {
       PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
        "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
   
       CIMSubscriptionInitCompleteRequestMessage * request =
           dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
               (const_cast <Message *> (message));
   
       PEGASUS_ASSERT (request != 0);
   
       CIMSubscriptionInitCompleteResponseMessage * response =
           dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
               (request->buildResponse ());
   
       PEGASUS_ASSERT (response != 0);
   
       //
       //  Set indicator
       //
       _subscriptionInitComplete = true;
   
       //
       //  For each provider that has at least one subscription, call
       //  provider's enableIndications method
       //
       Array <JMPIProvider *> enableProviders;
       enableProviders = providerManager.getIndicationProvidersToEnable ();
   
       Uint32 numProviders = enableProviders.size ();
       for (Uint32 i = 0; i < numProviders; i++)
       {
           try
           {
               CIMInstance provider;
               provider = enableProviders [i]->getProviderInstance ();
   
               //
               //  Get cached or load new provider module
               //
               JMPIProvider::OpProviderHolder ph = providerManager.getProvider
                   (enableProviders [i]->getModule ()->getFileName (),
                    enableProviders [i]->getName ());
   
               indProvRecord * prec = NULL;
               provTab.lookup (enableProviders [i]->getName (), prec);
               if (prec)
               {
                   prec->enabled = true;
                   CIMRequestMessage * request = 0;
                   CIMResponseMessage * response = 0;
                   prec->handler = new EnableIndicationsResponseHandler
                       (request, response, provider, _indicationCallback);
               }
           }
           catch (CIMException & e)
           {
               PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                   "CIMException: " + e.getMessage ());
           }
           catch (Exception & e)
           {
               PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                   "Exception: " + e.getMessage ());
           }
           catch(...)
           {
               PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                   "Unknown error in handleSubscriptionInitCompleteRequest");
           }
       }
   
       PEG_METHOD_EXIT ();
       return (response);
   }
   
 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw() Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
 { {
   PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,   PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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