(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.24.6.5 and 1.25

version 1.24.6.5, 2004/04/05 08:55:51 version 1.25, 2004/02/04 22:58:21
Line 42 
Line 42 
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/Destroyer.h> #include <Pegasus/Common/Destroyer.h>
 #include <Pegasus/ProviderManager2/OperationResponseHandler.h>  #include <Pegasus/ProviderManager/OperationResponseHandler.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
Line 267 
Line 267 
  
         _incomingQueue.enqueue(request->op);         _incomingQueue.enqueue(request->op);
  
          while (!_thread_pool->allocate_and_awaken(          _thread_pool->allocate_and_awaken((void *)this, ProviderManagerService::handleCimOperation);
                      (void *)this, ProviderManagerService::handleCimOperation))  
          {  
              pegasus_yield();  
          }  
     }     }
     else     else
     {     {
Line 391 
Line 387 
     if (pm) {     if (pm) {
         response = pm->processMessage(request);         response = pm->processMessage(request);
     }     }
       else
     else for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {      {
          if (request->getType()==CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) {
             for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {
        ProviderManagerContainer *pmc=_providerManagers[i];        ProviderManagerContainer *pmc=_providerManagers[i];
        switch (message->getType()) {  // ---- next instruction is disabled because of a bug
        case CIM_ENABLE_MODULE_REQUEST_MESSAGE: {  //             response=pmc->getProviderManager()->processMessage(request);
              CIMEnableModuleRequestMessage * request =  // ---- this block is an workaround
                 dynamic_cast<CIMEnableModuleRequestMessage*>(const_cast<Message*>(message));              CIMStopAllProvidersResponseMessage * resp =
              if (request->providerModule.getProperty(request->providerModule.findProperty                new CIMStopAllProvidersResponseMessage(
                  ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())                   request->messageId,
              response=pmc->getProviderManager()->processMessage(request);                   CIMException(),
           }                   ((CIMStopAllProvidersRequestMessage*)request)->queueIds.copyAndPop());
                resp->setKey(request->getKey());
                resp->setHttpMethod (request->getHttpMethod ());
                response=resp;
           break;           break;
        case CIM_DISABLE_MODULE_REQUEST_MESSAGE: {  // ---- end of  workaround
              CIMDisableModuleRequestMessage * request =  
                 dynamic_cast<CIMDisableModuleRequestMessage*>(const_cast<Message*>(message));  
              if (request->providerModule.getProperty(request->providerModule.findProperty  
                  ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())  
              response=pmc->getProviderManager()->processMessage(request);  
           }           }
           break;         }
        case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: {         else {
           Message  *resp=pmc->getProviderManager()->processMessage(request);  
           if (resp) response=resp; }  
           break;  
        default:  
           CIMRequestMessage * req =           CIMRequestMessage * req =
               dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));               dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
           CIMResponseMessage  *resp=new CIMResponseMessage(0,req->messageId,CIMException(),           CIMResponseMessage  *resp=new CIMResponseMessage(0,req->messageId,CIMException(),
Line 423 
Line 415 
           response=resp;           response=resp;
           resp->synch_response(req);           resp->synch_response(req);
           OperationResponseHandler handler(req, resp);           OperationResponseHandler handler(req, resp);
           handler.setStatus(CIM_ERR_FAILED, "Unknown messagetype.");            handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
        }        }
     }     }
  
Line 450 
Line 442 
 { {
     CIMNamespaceName nameSpace;     CIMNamespaceName nameSpace;
     CIMName className;     CIMName className;
     CIMName method;  
  
     const CIMOperationRequestMessage * p =     const CIMOperationRequestMessage * p =
        dynamic_cast<const CIMOperationRequestMessage *>(message);        dynamic_cast<const CIMOperationRequestMessage *>(message);
  
     if (p) {     if (p) {
        nameSpace=p->nameSpace;        nameSpace=p->nameSpace;
   
        if (p->providerType==ProviderType::ASSOCIATION)        if (p->providerType==ProviderType::ASSOCIATION)
           className=((CIMAssociatorsRequestMessage*)p)->assocClass;           className=((CIMAssociatorsRequestMessage*)p)->assocClass;
        else className=p->className;        else className=p->className;
  
        if (p->providerType==ProviderType::METHOD)         ProviderName name(
           method=((CIMInvokeMethodRequestMessage*)p)->methodName;             CIMObjectPath(String::EMPTY, nameSpace, className).toString(),
              String::EMPTY,
        ProviderName name(nameSpace,             String::EMPTY,
            className,             String::EMPTY,
            p->providerType,             p->providerType);
            method);  
   
        // find provider manager        // find provider manager
        name = ProviderRegistrar().findProvider(name,false);         name = ProviderRegistrar().findProvider(name);
        it=name.getInterfaceName();        it=name.getInterfaceName();
     }     }
  
Line 483 
Line 471 
           it=m->providerModule.getProperty (m->providerModule.findProperty           it=m->providerModule.getProperty (m->providerModule.findProperty
                 ("InterfaceType")).getValue ().toString ();                 ("InterfaceType")).getValue ().toString ();
        }        }
   /*       else {
        else switch (message->getType()) {            const CIMConsumeIndicationRequestMessage * p =
        case CIM_DISABLE_MODULE_REQUEST_MESSAGE:              dynamic_cast<const CIMConsumeIndicationRequestMessage *>(message);
        case CIM_ENABLE_MODULE_REQUEST_MESSAGE:            if (p) {
        case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:               CIMConsumeIndicationRequestMessage *m=(CIMConsumeIndicationRequestMessage*)message;
           return NULL;               it=m->consumer_module.getProperty (m->consumer_module.findProperty
        default:                  ("InterfaceType")).getValue ().toString ();
             } */
             else {  // remaining functions are sent to default provider
   //           cout<<"--- ProviderManagerService::locateProviderManager(): unknown message type: "<<
   //              message->getType()<<endl;
           it="C++Default";           it="C++Default";
   //           return NULL;
        }        }
    //      }
     }     }
  
     // find provider manager for provider interface     // find provider manager for provider interface
Line 508 
Line 502 
  
 void ProviderManagerService::unload_idle_providers(void) void ProviderManagerService::unload_idle_providers(void)
 { {
     for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)  
     {  
       ProviderManagerContainer *pmc=_providerManagers[i];  
            pmc->getProviderManager()->unload_idle_providers();  
     }  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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