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

version 1.25, 2004/02/04 22:58:21 version 1.30, 2004/03/23 15:51:32
Line 31 
Line 31 
 //              Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. //              Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
 //              Adrian Schuur, IBM (schuur@de.ibm.com) //              Adrian Schuur, IBM (schuur@de.ibm.com)
   //              Dan Gorey, djgorey@us.ibm.com
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 42 
Line 43 
 #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/ProviderManager/OperationResponseHandler.h>  #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
  
Line 385 
Line 386 
     // get the responsible provider Manager     // get the responsible provider Manager
     ProviderManager * pm = locateProviderManager(message,ifc);     ProviderManager * pm = locateProviderManager(message,ifc);
     if(pm) {     if(pm) {
         response = pm->processMessage(request);          response = pm->processMessage(request,providerManagerName);
     }     }
     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];
 // ---- next instruction is disabled because of a bug         switch (message->getType()) {
 //             response=pmc->getProviderManager()->processMessage(request);         case CIM_ENABLE_MODULE_REQUEST_MESSAGE: {
 // ---- this block is an workaround               CIMEnableModuleRequestMessage * request =
             CIMStopAllProvidersResponseMessage * resp =                  dynamic_cast<CIMEnableModuleRequestMessage*>(const_cast<Message*>(message));
               new CIMStopAllProvidersResponseMessage(               if (request->providerModule.getProperty(request->providerModule.findProperty
                  request->messageId,                   ("InterfaceType")).getValue().toString()==pmc->getInterfaceName())
                  CIMException(),               response=pmc->getProviderManager()->processMessage(request,providerManagerName);
                  ((CIMStopAllProvidersRequestMessage*)request)->queueIds.copyAndPop());  
              resp->setKey(request->getKey());  
              resp->setHttpMethod (request->getHttpMethod ());  
              response=resp;  
              break;  
 // ---- end of  workaround  
            }            }
             break;
          case CIM_DISABLE_MODULE_REQUEST_MESSAGE: {
                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,providerManagerName);
        }        }
        else {            break;
          case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: {
             Message  *resp=pmc->getProviderManager()->processMessage(request,providerManagerName);
             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 415 
Line 420 
           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 error.");            handler.setStatus(CIM_ERR_FAILED, "Unknown messagetype.");
        }        }
     }     }
  
Line 442 
Line 447 
 { {
     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;
  
        ProviderName name(         if (p->providerType==ProviderType::METHOD)
            CIMObjectPath(String::EMPTY, nameSpace, className).toString(),            method=((CIMInvokeMethodRequestMessage*)p)->methodName;
            String::EMPTY,  
            String::EMPTY,         ProviderName name(nameSpace,
            String::EMPTY,             className,
            p->providerType);             p->providerType,
              method);
   
        // find provider manager        // find provider manager
        name = ProviderRegistrar().findProvider(name);         name = ProviderRegistrar().findProvider(name,false);
          providerManagerName = name;
        it=name.getInterfaceName();        it=name.getInterfaceName();
     }     }
  
Line 471 
Line 481 
           it=m->providerModule.getProperty (m->providerModule.findProperty           it=m->providerModule.getProperty (m->providerModule.findProperty
                 ("InterfaceType")).getValue ().toString ();                 ("InterfaceType")).getValue ().toString ();
        }        }
 /*       else {  
           const CIMConsumeIndicationRequestMessage * p =         else switch (message->getType()) {
             dynamic_cast<const CIMConsumeIndicationRequestMessage *>(message);         case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
           if (p) {         case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
              CIMConsumeIndicationRequestMessage *m=(CIMConsumeIndicationRequestMessage*)message;         case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
              it=m->consumer_module.getProperty (m->consumer_module.findProperty            return NULL;
                 ("InterfaceType")).getValue ().toString ();         default:
           } */  
           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

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