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

Diff for /pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp between version 1.12 and 1.51

version 1.12, 2004/01/27 13:48:11 version 1.51, 2005/03/04 03:12:45
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 30 
Line 34 
 //              Mike Day, IBM (mdday@us.ibm.com) //              Mike Day, IBM (mdday@us.ibm.com)
 //              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)
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Seema Gupta (gseema@in.ibm.com) for PEP135
   //              Willis White (whiwill@us.ibm.com)
   //              Josephine Eskaline Joyce (jojustin@in.ibm.com) for PEP#101
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 45 
  
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
 #include <Pegasus/Common/OperationContext.h> #include <Pegasus/Common/OperationContext.h>
 #include <Pegasus/Common/Destroyer.h>  
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/MessageLoader.h> //l10n #include <Pegasus/Common/MessageLoader.h> //l10n
   #include <Pegasus/Common/Constants.h>
  
 #include <Pegasus/Common/QueryExpression.h>  #include <Pegasus/Query/QueryExpression/QueryExpression.h>
 #include <Pegasus/ProviderManager2/QueryExpressionFactory.h> #include <Pegasus/ProviderManager2/QueryExpressionFactory.h>
  
 #include <Pegasus/Config/ConfigManager.h>  
   
 #include <Pegasus/ProviderManager2/Default/Provider.h> #include <Pegasus/ProviderManager2/Default/Provider.h>
 #include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h>  #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
  
 #include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>  #include <Pegasus/ProviderManager2/ProviderManagerService.h>
   #include <Pegasus/ProviderManager2/ProviderType.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 76 
Line 83 
 }; };
  
 // //
 // Provider module status  // Default Provider Manager
 // //
 static const Uint16 _MODULE_OK       = 2;  
 static const Uint16 _MODULE_STOPPING = 9;  
 static const Uint16 _MODULE_STOPPED  = 10;  
   
 // provider manager  
 static LocalProviderManager providerManager;  
   
 DefaultProviderManager::DefaultProviderManager(void) DefaultProviderManager::DefaultProviderManager(void)
 { {
       _subscriptionInitComplete = false;
 } }
  
 DefaultProviderManager::~DefaultProviderManager(void) DefaultProviderManager::~DefaultProviderManager(void)
 { {
 } }
  
 Message * DefaultProviderManager::processMessage(Message * request) throw()  Message * DefaultProviderManager::processMessage(Message * request)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "DefaultProviderManager::processMessage()");         "DefaultProviderManager::processMessage()");
Line 171 
Line 172 
         response = handleDeleteSubscriptionRequest(request);         response = handleDeleteSubscriptionRequest(request);
  
         break;         break;
     case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:      case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
         response = handleEnableIndicationsRequest(request);          response = handleExportIndicationRequest(request);
   
         break;  
     case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:  
         response = handleDisableIndicationsRequest(request);  
   
         break;  
     case CIM_CONSUME_INDICATION_REQUEST_MESSAGE:  
         response = handleConsumeIndicationRequest(request);  
         break;         break;
  
     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:     case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
Line 195 
Line 188 
         response = handleStopAllProvidersRequest(request);         response = handleStopAllProvidersRequest(request);
  
         break;         break;
       case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
           response = handleInitializeProviderRequest(request);
   
           break;
       case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
           response = handleSubscriptionInitCompleteRequest (request);
   
           break;
     default:     default:
         response = handleUnsupportedRequest(request);         response = handleUnsupportedRequest(request);
  
Line 206 
Line 207 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw()  Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest");
  
Line 216 
Line 217 
     return(0);     return(0);
 } }
  
 Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw()  Message * DefaultProviderManager::handleInitializeProviderRequest(
       const Message * message)
   {
       PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
           "DefaultProviderManager::handleInitializeProviderRequest");
   
       CIMInitializeProviderRequestMessage * request =
           dynamic_cast<CIMInitializeProviderRequestMessage *>
               (const_cast<Message *>(message));
   
       PEGASUS_ASSERT(request != 0);
   
       CIMInitializeProviderResponseMessage * response =
           new CIMInitializeProviderResponseMessage(
           request->messageId,
           CIMException(),
           request->queueIds.copyAndPop());
   
       // preserve message key
       response->setKey(request->getKey());
   
       //  Set HTTP method in response from request
       response->setHttpMethod(request->getHttpMethod());
   
       OperationResponseHandler handler(request, response);
   
       try
       {
           // resolve provider name
           ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
   
           // get cached or load new provider module
           OpProviderHolder ph = providerManager.getProvider(
               name.getPhysicalName(), name.getLogicalName());
       }
       catch(CIMException & e)
       {
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
               "CIMException: " + e.getMessage());
   
           handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage());
       }
       catch(Exception & e)
       {
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
               "Exception: " + e.getMessage());
   
           handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage());
       }
       catch(...)
       {
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
               "Exception: Unknown");
   
           handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
       }
   
       PEG_METHOD_EXIT();
   
       return(response);
   }
   
   Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest");
  
Line 258 
Line 322 
             request->instanceName.getClassName(),             request->instanceName.getClassName(),
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMPropertyList propertyList(request->propertyList);         CIMPropertyList propertyList(request->propertyList);
  
Line 327 
Line 385 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()  Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest");
  
Line 368 
Line 426 
             request->nameSpace,             request->nameSpace,
             request->className);             request->className);
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),          OpProviderHolder ph = providerManager.getProvider(
                 name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMPropertyList propertyList(request->propertyList);         CIMPropertyList propertyList(request->propertyList);
  
Line 437 
Line 489 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()  Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest");
  
Line 479 
Line 531 
             request->nameSpace,             request->nameSpace,
             request->className);             request->className);
  
         // build an internal provider name from the request arguments  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         // forward request         // forward request
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
Line 544 
Line 589 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw()  Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest");
  
Line 587 
Line 632 
             request->newInstance.getPath().getClassName(),             request->newInstance.getPath().getClassName(),
             request->newInstance.getPath().getKeyBindings());             request->newInstance.getPath().getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         // forward request         // forward request
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
Line 652 
Line 691 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw()  Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest");
  
Line 694 
Line 733 
             request->modifiedInstance.getPath ().getClassName(),             request->modifiedInstance.getPath ().getClassName(),
             request->modifiedInstance.getPath ().getKeyBindings());             request->modifiedInstance.getPath ().getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMPropertyList propertyList(request->propertyList);         CIMPropertyList propertyList(request->propertyList);
  
Line 763 
Line 796 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw()  Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest");
  
Line 805 
Line 838 
             request->instanceName.getClassName(),             request->instanceName.getClassName(),
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::INSTANCE);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         // forward request         // forward request
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
Line 869 
Line 896 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) throw()  Message * DefaultProviderManager::handleExecQueryRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");
  
Line 910 
Line 937 
             request->nameSpace,             request->nameSpace,
             request->className);             request->className);
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             ProviderType::QUERY);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(),              name.getPhysicalName(), name.getLogicalName());
                                         name.getLogicalName(), String::EMPTY);  
  
         if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) {         if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) {
            String errorString = " instance provider is registered supporting execQuery "            String errorString = " instance provider is registered supporting execQuery "
Line 935 
Line 955 
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         QueryExpression qx(QueryExpressionFactory::routeBuildQueryExpressionRep          QueryExpression qx(request->queryLanguage,request->query);
             (request->queryLanguage,request->query));  
  
         // forward request         // forward request
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
Line 968 
Line 987 
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
            cout<<"--- exception not a CIMInstanceQueryProvider"<<endl;  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
  
Line 987 
Line 1005 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw()  Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest");
  
Line 1028 
Line 1046 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         ProviderName name(          CIMObjectPath assocPath(
             objectPath.toString(),              System::getHostName(),
             String::EMPTY,              request->nameSpace,
             String::EMPTY,              request->assocClass.getString());
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
  
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         // ATTN KS STAT_GETSTARTTIME;          STAT_GETSTARTTIME;
         pm_service_op_lock op_lock(&ph.GetProvider());         pm_service_op_lock op_lock(&ph.GetProvider());
  
         ph.GetProvider().associators(         ph.GetProvider().associators(
Line 1061 
Line 1078 
             request->resultRole,             request->resultRole,
             request->includeQualifiers,             request->includeQualifiers,
             request->includeClassOrigin,             request->includeClassOrigin,
             request->propertyList.getPropertyNameArray(),              request->propertyList,
             handler);             handler);
  
         STAT_PMS_PROVIDEREND;         STAT_PMS_PROVIDEREND;
Line 1093 
Line 1110 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message) throw()  Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest");
  
Line 1137 
Line 1154 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         ProviderName name(          CIMObjectPath assocPath(
             objectPath.toString(),              System::getHostName(),
             String::EMPTY,              request->nameSpace,
             String::EMPTY,              request->assocClass.getString());
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
  
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
                   STAT_GETSTARTTIME;
         pm_service_op_lock op_lock(&ph.GetProvider());         pm_service_op_lock op_lock(&ph.GetProvider());
  
         ph.GetProvider().associatorNames(         ph.GetProvider().associatorNames(
Line 1198 
Line 1215 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw()  Message * DefaultProviderManager::handleReferencesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest");
  
Line 1242 
Line 1259 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         ProviderName name(          CIMObjectPath resultPath(
             objectPath.toString(),              System::getHostName(),
             String::EMPTY,              request->nameSpace,
             String::EMPTY,              request->resultClass.getString());
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
  
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         STAT_GETSTARTTIME;         STAT_GETSTARTTIME;
  
Line 1278 
Line 1294 
             request->role,             request->role,
             request->includeQualifiers,             request->includeQualifiers,
             request->includeClassOrigin,             request->includeClassOrigin,
             request->propertyList.getPropertyNameArray(),              request->propertyList,
             handler);             handler);
  
         STAT_PMS_PROVIDEREND;         STAT_PMS_PROVIDEREND;
Line 1310 
Line 1326 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw()  Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest");
  
Line 1352 
Line 1368 
  
         objectPath.setKeyBindings(request->objectName.getKeyBindings());         objectPath.setKeyBindings(request->objectName.getKeyBindings());
  
         ProviderName name(          CIMObjectPath resultPath(
             objectPath.toString(),              System::getHostName(),
             String::EMPTY,              request->nameSpace,
             String::EMPTY,              request->resultClass.getString());
             String::EMPTY,  
             ProviderType::ASSOCIATION);  
  
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         STAT_GETSTARTTIME;         STAT_GETSTARTTIME;
  
Line 1417 
Line 1432 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw()  Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest");
  
Line 1459 
Line 1474 
             request->instanceName.getClassName(),             request->instanceName.getClassName(),
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMName propertyName = request->propertyName;         CIMName propertyName = request->propertyName;
  
Line 1526 
Line 1535 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw()  Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest");
  
Line 1570 
Line 1579 
             request->instanceName.getClassName(),             request->instanceName.getClassName(),
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMName propertyName = request->propertyName;         CIMName propertyName = request->propertyName;
         CIMValue propertyValue = request->newValue;         CIMValue propertyValue = request->newValue;
Line 1639 
Line 1642 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw()  Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest");
  
Line 1684 
Line 1687 
             request->instanceName.getClassName(),             request->instanceName.getClassName(),
             request->instanceName.getKeyBindings());             request->instanceName.getKeyBindings());
  
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
               request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(ContentLanguageListContainer(request->contentLanguages));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         CIMObjectPath instanceReference(request->instanceName);         CIMObjectPath instanceReference(request->instanceName);
  
Line 1755 
Line 1752 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()  Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");
  
Line 1800 
Line 1797 
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         // NOTE: the provider and provider module name are embedded in the request, presumably to reduce                  CIMInstance req_provider, req_providerModule;
         // the number of provider lookups (but this should be trivial if the data is cached and accessed                  ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
         // from the same source). to keep the lookups consistent, use the first class name, combined                  req_provider = pidc.getProvider();
         // with the other information in the request, and create an object path that can be used to                  req_providerModule = pidc.getModule();
         // resolve the provider using the ProviderRegistrar.  
           String physicalName=_resolvePhysicalName( req_providerModule.getProperty(
         // make target object path                                                    req_providerModule.findProperty("Location")).getValue().toString());
         CIMObjectPath objectPath(  
             System::getHostName(),          ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),
             request->nameSpace,                                    physicalName,
             request->classNames[0].getString());                                    req_providerModule.getProperty(req_providerModule.findProperty
                                     ("InterfaceType")).getValue().toString(),
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);             0);
  
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
   
           //
           //  Save the provider instance from the request
           //
           ph.GetProvider ().setProviderInstance (req_provider);
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(SubscriptionInstanceContainer                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
             (request->subscriptionInstance));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
         context.insert(SubscriptionFilterConditionContainer              context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
             (request->condition, request->queryLanguage));              context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
         context.insert(SubscriptionLanguageListContainer              context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
             (request->acceptLanguages));                   context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
  
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
  
Line 1869 
Line 1861 
             classNames,             classNames,
             propertyList,             propertyList,
             repeatNotificationPolicy);             repeatNotificationPolicy);
   
           //
           //  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)
               {
                   _callEnableIndications (req_provider,
                       _indicationCallback, ph);
               }
           }
     }     }
     catch(CIMException & e)     catch(CIMException & e)
     {     {
Line 1897 
Line 1906 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw()  Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest");
  
Line 1937 
Line 1946 
         }         }
  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
             "DefaultProviderManager::handleModifySubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",              "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0  Name space: $1  Class name(s): $2",
             System::getHostName(),             System::getHostName(),
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         // NOTE: the provider and provider module name are embedded in the request, presumably to reduce                  CIMInstance req_provider, req_providerModule;
         // the number of provider lookups (but this should be trivial if the data is cached and accessed                  ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
         // from the same source). to keep the lookups consistent, use the first class name, combined                  req_provider = pidc.getProvider();
         // with the other information in the request, and create an object path that can be used to                  req_providerModule = pidc.getModule();
         // resolve the provider using the ProviderRegistrar.  
           String physicalName=_resolvePhysicalName( req_providerModule.getProperty(
         // make target object path                                                    req_providerModule.findProperty("Location")).getValue().toString());
         CIMObjectPath objectPath(  
             System::getHostName(),          ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),
             request->nameSpace,                                    physicalName,
             request->classNames[0].getString());                                    req_providerModule.getProperty(req_providerModule.findProperty
                                     ("InterfaceType")).getValue().toString(),
         ProviderName name(  
             objectPath.toString(),  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);             0);
  
         // resolve provider name  
         name = _resolveProviderName(name);  
   
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
                   context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
         context.insert(SubscriptionInstanceContainer              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
             (request->subscriptionInstance));              context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
         context.insert(SubscriptionFilterConditionContainer              context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
             (request->condition, request->queryLanguage));              context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
         context.insert(SubscriptionLanguageListContainer                   context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));
             (request->acceptLanguages));  
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
  
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
  
Line 2039 
Line 2037 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()  Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest");
  
Line 2084 
Line 2082 
             request->nameSpace.getString(),             request->nameSpace.getString(),
             temp);             temp);
  
         // NOTE: the provider and provider module name are embedded in the request, presumably to reduce                  CIMInstance req_provider, req_providerModule;
         // the number of provider lookups (but this should be trivial if the data is cached and accessed                  ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
         // from the same source). to keep the lookups consistent, use the first class name, combined  
         // with the other information in the request, and create an object path that can be used to  
         // resolve the provider using the ProviderRegistrar.  
  
         // make target object path                  req_provider = pidc.getProvider();
         CIMObjectPath objectPath(                  req_providerModule = pidc.getModule();
             System::getHostName(),  
             request->nameSpace,  
             request->classNames[0].getString());  
  
         ProviderName name(                String physicalName=_resolvePhysicalName( req_providerModule.getProperty(
             objectPath.toString(),                                                    req_providerModule.findProperty("Location")).getValue().toString());
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
  
         // resolve provider name                ProviderName name(req_provider.getProperty(req_provider.findProperty("Name")).getValue ().toString (),
         name = _resolveProviderName(name);                                    physicalName,
                                     req_providerModule.getProperty(req_providerModule.findProperty
                                     ("InterfaceType")).getValue().toString(),
                                      0);
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
  
         // convert arguments         // convert arguments
         OperationContext context;         OperationContext context;
  
         context.insert(IdentityContainer(request->userName));                  context.insert(request->operationContext.get(IdentityContainer::NAME));
         context.insert(SubscriptionInstanceContainer                  context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
             (request->subscriptionInstance));              context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
         context.insert(SubscriptionLanguageListContainer              context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
             (request->acceptLanguages));              context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
         context.insert(AcceptLanguageListContainer(request->acceptLanguages));  
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
  
         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();         CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
  
Line 2145 
Line 2134 
             context,             context,
             subscriptionName,             subscriptionName,
             classNames);             classNames);
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(Exception & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
   
         handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n  
     }  
     catch(...)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: Unknown");  
   
         handler.setStatus(CIM_ERR_FAILED, "Unknown Error");  
     }  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest");  
   
     CIMEnableIndicationsRequestMessage * request =  
         dynamic_cast<CIMEnableIndicationsRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMEnableIndicationsResponseMessage * response =  
         new CIMEnableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     CIMEnableIndicationsResponseMessage * responseforhandler =  
         new CIMEnableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod(request->getHttpMethod());  
   
     response->dest = request->queueIds.top();  
   
     /*  
     // ATTN: need pointer to Provider Manager Server!  
     //EnableIndicationsResponseHandler *handler =  
     //    new EnableIndicationsResponseHandler(request, response, this);  
   
     try  
     {  
         // get the provider file name and logical name  
         Triad<String, String, String> triad =  
             _getProviderRegPair(request->provider, request->providerModule);  
   
         // get cached or load new provider module  
         //Provider provider =  
         OpProviderHolder ph =  
             providerManager.getProvider(triad.first, triad.second, triad.third);  
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,          //
             "Calling provider.enableIndications: " +          //  Decrement count of current subscriptions for this provider
             ph.GetProvider().getName());          //
         ph.GetProvider().protect();          if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
         ph.GetProvider().enableIndications(*handler);  
   
   
         // if no exception, store the handler so it is persistent for as  
         // long as the provider has indications enabled.  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Storing indication handler for " + ph.GetProvider().getName());  
   
         _insertEntry(ph.GetProvider(), handler);  
     }  
     catch(CIMException & e)  
     {  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Exception: " + e.getMessage());  
         response->cimException = CIMException(e);  
     }  
     catch(Exception & e)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,              //
             "Exception: " + e.getMessage());              //  If there are no current subscriptions after the decrement,
         //l10n              //  the last subscription has been deleted
         //response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");              //  Call the provider's disableIndications method
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(              //
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",              if (_subscriptionInitComplete)
             "Internal Error"));  
     }  
     catch(...)  
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: Unknown");  
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");  
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",  
             "Unknown Error"));  
     }  
     */  
   
     PEG_METHOD_EXIT();  
   
     return(response);  
 }  
   
 Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw()  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest");  
   
     CIMDisableIndicationsRequestMessage * request =  
         dynamic_cast<CIMDisableIndicationsRequestMessage *>(const_cast<Message *>(message));  
   
     PEGASUS_ASSERT(request != 0);  
   
     CIMDisableIndicationsResponseMessage * response =  
         new CIMDisableIndicationsResponseMessage(  
         request->messageId,  
         CIMException(),  
         request->queueIds.copyAndPop());  
   
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key  
     response->setKey(request->getKey());  
   
     //  Set HTTP method in response from request  
     response->setHttpMethod (request->getHttpMethod ());  
   
     OperationResponseHandler handler(request, response);  
   
     try  
     {  
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
         /*  
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             objectPath.toString());  
   
         // resolve provider name  
         name = _resolveProviderName(name);  
         */  
   
         // get cached or load new provider module  
         OpProviderHolder ph =  
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);  
   
         /*  
         // get the provider file name and logical name  
         Triad<String, String, String> triad =  
             getProviderRegistrar()->_getProviderRegPair(request->provider, request->providerModule);  
   
         // get cached or load new provider module  
         //Provider provider =  
         OpProviderHolder ph =  
             providerManager.getProvider(triad.first, triad.second, triad.third);  
         */  
   
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,  
             "Calling provider.disableIndications: " +             "Calling provider.disableIndications: " +
             ph.GetProvider().getName());             ph.GetProvider().getName());
  
Line 2333 
Line 2155 
  
         ph.GetProvider().unprotect();         ph.GetProvider().unprotect();
  
                   //
                   //
                   //
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Removing and Destroying indication handler for " +             "Removing and Destroying indication handler for " +
             ph.GetProvider().getName());             ph.GetProvider().getName());
  
         delete _removeEntry(_generateKey(ph.GetProvider()));         delete _removeEntry(_generateKey(ph.GetProvider()));
     }     }
           }
       }
     catch(CIMException & e)     catch(CIMException & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
  
         response->cimException = CIMException(e);          handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
             response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",          handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
             "Internal Error"));  
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: Unknown");             "Exception: Unknown");
             response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",          handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
             "Unknown Error"));  
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 2369 
Line 2193 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message *message) throw()  Message *DefaultProviderManager::handleExportIndicationRequest(const Message *message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest");
  
     CIMConsumeIndicationRequestMessage *request =      CIMExportIndicationRequestMessage * request =
         dynamic_cast<CIMConsumeIndicationRequestMessage *>(const_cast<Message *>(message));          dynamic_cast<CIMExportIndicationRequestMessage *>(const_cast<Message *>(message));
  
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     CIMResponseMessage * response =      CIMExportIndicationResponseMessage * response =
         new CIMResponseMessage(          new CIMExportIndicationResponseMessage(
         CIM_CONSUME_INDICATION_RESPONSE_MESSAGE,  
         request->messageId,         request->messageId,
         CIMException(),         CIMException(),
         request->queueIds.copyAndPop());         request->queueIds.copyAndPop());
  
     PEGASUS_ASSERT(response != 0);     PEGASUS_ASSERT(response != 0);
  
       // preserve message key
     response->setKey(request->getKey());     response->setKey(request->getKey());
  
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
     Uint32 type = 3;      OperationResponseHandler handler(request, response);
  
     try     try
     {     {
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             String::EMPTY,  
             0);  
   
         /*  
         ProviderName name(  
             String::EMPTY,  
             String::EMPTY,  
             objectPath.toString());  
   
         // resolve provider name         // resolve provider name
         name = _resolveProviderName(name);          ProviderName name = _resolveProviderName(
         */              request->operationContext.get(ProviderIdContainer::NAME));
  
         // get cached or load new provider module         // get cached or load new provider module
         OpProviderHolder ph =          OpProviderHolder ph = providerManager.getProvider(
             providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);              name.getPhysicalName(), name.getLogicalName());
   
                   STAT_GETSTARTTIME
  
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Calling provider.: " +             "Calling provider.: " +
Line 2423 
Line 2236 
  
         OperationContext context;         OperationContext context;
  
   //L10N_TODO
         //l10n         //l10n
         // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent.  This         // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent.  This
         // does not appear to be hooked-up.  When it is added, need to         // does not appear to be hooked-up.  When it is added, need to
         // make sure that Content-Language is set in the consume msg.         // make sure that Content-Language is set in the consume msg.
         // NOTE: A-L is not needed to be set in the consume msg.         // NOTE: A-L is not needed to be set in the consume msg.
         // add the langs to the context         // add the langs to the context
         context.insert(ContentLanguageListContainer(request->contentLanguages));  
  
         CIMInstance indication_copy = request->indicationInstance;        context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
  
         SimpleIndicationResponseHandler handler;        CIMInstance indication_copy = request->indicationInstance;
         pm_service_op_lock op_lock(&ph.GetProvider());
  
         ph.GetProvider().consumeIndication(context,         ph.GetProvider().consumeIndication(context,
             "",                                  request->destinationPath,
             indication_copy);             indication_copy);
   
             STAT_PMS_PROVIDEREND
   
     }     }
   
     catch(CIMException & e)     catch(CIMException & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
  
         response->cimException = CIMException(e);          handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n
     }     }
     catch(Exception & e)     catch(Exception & e)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: " + e.getMessage());             "Exception: " + e.getMessage());
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");          handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.INTERNAL_ERROR",  
             "Internal Error"));  
     }     }
     catch(...)     catch(...)
     {     {
         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             "Exception: Unknown");             "Exception: Unknown");
         //l10n  
         //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");          handler.setStatus(CIM_ERR_FAILED, "Unknown Error");
         response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR",  
             "Unknown Error"));  
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 2472 
Line 2284 
     return(response);     return(response);
 } }
  
   
   
   
 // //
 // This function disables a provider module if disableProviderOnly is not true, // This function disables a provider module if disableProviderOnly is not true,
 // otherwise, disables a provider. Disable provider module means that // otherwise, disables a provider. Disable provider module means that
Line 2481 
Line 2296 
 // //
 // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider. // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider.
 // //
 Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw()  Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message)
 { {
     // HACK  
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();  
   
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");
  
     CIMDisableModuleRequestMessage * request =     CIMDisableModuleRequestMessage * request =
Line 2493 
Line 2305 
  
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
       Array<Uint16> operationalStatus;
       CIMException cimException;
   
       try
       {
     // get provider module name     // get provider module name
     String moduleName;     String moduleName;
     CIMInstance mInstance = request->providerModule;     CIMInstance mInstance = request->providerModule;
     Uint32 pos = mInstance.findProperty(CIMName ("Name"));     Uint32 pos = mInstance.findProperty(CIMName ("Name"));
           PEGASUS_ASSERT(pos != PEG_NOT_FOUND);
     if(pos != PEG_NOT_FOUND)  
     {  
         mInstance.getProperty(pos).getValue().get(moduleName);         mInstance.getProperty(pos).getValue().get(moduleName);
     }  
  
     Boolean disableProviderOnly = request->disableProviderOnly;     Boolean disableProviderOnly = request->disableProviderOnly;
  
     //     //
     // get operational status          // Unload providers
     //     //
     Array<Uint16> operationalStatus;          Array<CIMInstance> _pInstances = request->providers;
           Array<Boolean> _indicationProviders = request->indicationProviders;
   
           String physicalName=_resolvePhysicalName(
              mInstance.getProperty(
                 mInstance.findProperty("Location")).getValue().toString());
  
     if(!disableProviderOnly)          for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)
     {     {
         Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus"));              String pName(_pInstances[i].getProperty(
                  _pInstances[i].findProperty("Name")).getValue().toString());
   
               Sint16 ret_value = providerManager.disableProvider(pName);
  
         if(pos2 != PEG_NOT_FOUND)              if (ret_value == 0)
               {
                   // disable failed since there are pending requests,
                   // stop trying to disable other providers in this module.
                   operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
                   break;
               }
               else if (ret_value == 1)  // Success
               {
                   if (_indicationProviders[i])
         {         {
             //             //
             //  ATTN-CAKG-P2-20020821: Check for null status?                      //  Reset the indication provider's count of current
                       //  subscriptions since it has been disabled
             //             //
             mInstance.getProperty(pos2).getValue().get(operationalStatus);                      if (physicalName.size () > 0)
                       {
                           OpProviderHolder ph = providerManager.getProvider(
                               physicalName, pName);
   
                           ph.GetProvider ().resetSubscriptions ();
         }         }
  
         //         //
         // update module status from OK to Stopping                      //  If it is an indication provider
                       //  remove the entry from the table since the
                       //  provider has been disabled
         //         //
         for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)                      delete _removeEntry(_generateKey(pName,physicalName));
         {                  }
             if(operationalStatus[i] == _MODULE_OK)              }
               else
             {             {
                 operationalStatus.remove(i);                  // disable failed for other reason, throw exception
                   throw PEGASUS_CIM_EXCEPTION_L(
                       CIM_ERR_FAILED,
                       MessageLoaderParms(
                           "ProviderManager.ProviderManagerService."
                               "DISABLE_PROVIDER_FAILED",
                           "Failed to disable the provider."));
             }             }
         }         }
         operationalStatus.append(_MODULE_STOPPING);      }
       catch(CIMException & e)
         if(_providerRegistrationManager->setProviderModuleStatus  
             (moduleName, operationalStatus) == false)  
         {         {
             //l10n          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");                           "Exception: " + e.getMessage());
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(          cimException = e;
                 "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",  
                 "set module status failed."));  
         }         }
       catch(Exception & e)
       {
           PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                            "Exception: " + e.getMessage());
           cimException = CIMException(CIM_ERR_FAILED, e.getMessage());
     }     }
       catch(...)
     // Unload providers  
     Array<CIMInstance> _pInstances = request->providers;  
   
     for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)  
     {     {
         /* temp disabled by Chip          PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
         // get the provider file name and logical name                           "Exception: Unknown");
         Triad<String, String, String> triad =          //l10n
             getProviderRegistrar()->_getProviderRegPair(_pInstances[i], mInstance);          //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");
           cimException = PEGASUS_CIM_EXCEPTION_L(
         providerManager.unloadProvider(triad.first, triad.second);              CIM_ERR_FAILED,
         */              MessageLoaderParms(
                   "ProviderManager.ProviderManagerService.UNKNOWN_ERROR",
                   "Unknown Error"));
     }     }
  
     if(!disableProviderOnly)      if (cimException.getCode() == CIM_ERR_SUCCESS)
     {     {
         // update module status from Stopping to Stopped          // Status is set to OK if a provider was busy
         for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)          if (operationalStatus.size() == 0)
         {         {
             if(operationalStatus[i] == _MODULE_STOPPING)              operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
             {  
                 operationalStatus.remove(i);  
             }             }
         }         }
       else
         operationalStatus.append(_MODULE_STOPPED);  
   
         if(_providerRegistrationManager->setProviderModuleStatus  
             (moduleName, operationalStatus) == false)  
         {         {
             //l10n          // If exception occurs, module is not stopped
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,          operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
             //"set module status failed.");  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(  
                 "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",  
                 "set module status failed."));  
         }  
     }     }
  
     CIMDisableModuleResponseMessage * response =     CIMDisableModuleResponseMessage * response =
Line 2591 
Line 2425 
         request->queueIds.copyAndPop(),         request->queueIds.copyAndPop(),
         operationalStatus);         operationalStatus);
  
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key     // preserve message key
     response->setKey(request->getKey());     response->setKey(request->getKey());
  
     //  
     //  Set HTTP method in response from request     //  Set HTTP method in response from request
     //  
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 2606 
Line 2436 
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw()  Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message)
 { {
     // HACK  
     ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();  
   
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest");
  
     CIMEnableModuleRequestMessage * request =     CIMEnableModuleRequestMessage * request =
Line 2618 
Line 2445 
  
     PEGASUS_ASSERT(request != 0);     PEGASUS_ASSERT(request != 0);
  
     //  
     // get module status  
     //  
     CIMInstance mInstance = request->providerModule;  
     Array<Uint16> operationalStatus;     Array<Uint16> operationalStatus;
     Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus"));      operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
   
     if(pos != PEG_NOT_FOUND)  
     {  
         //  
         //  ATTN-CAKG-P2-20020821: Check for null status?  
         //  
         mInstance.getProperty(pos).getValue().get(operationalStatus);  
     }  
   
     // update module status from Stopped to OK  
     for(Uint32 i=0, n = operationalStatus.size(); i < n; i++)  
     {  
         if(operationalStatus[i] == _MODULE_STOPPED)  
         {  
             operationalStatus.remove(i);  
         }  
     }  
   
     operationalStatus.append(_MODULE_OK);  
   
     //  
     // get module name  
     //  
     String moduleName;  
   
     Uint32 pos2 = mInstance.findProperty(CIMName ("Name"));  
   
     if(pos2 != PEG_NOT_FOUND)  
     {  
         mInstance.getProperty(pos2).getValue().get(moduleName);  
     }  
   
     if(_providerRegistrationManager->setProviderModuleStatus  
         (moduleName, operationalStatus) == false)  
     {  
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed.");  
         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(  
             "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED",  
             "set module status failed."));  
     }  
  
     CIMEnableModuleResponseMessage * response =     CIMEnableModuleResponseMessage * response =
         new CIMEnableModuleResponseMessage(         new CIMEnableModuleResponseMessage(
Line 2673 
Line 2455 
         request->queueIds.copyAndPop(),         request->queueIds.copyAndPop(),
         operationalStatus);         operationalStatus);
  
     PEGASUS_ASSERT(response != 0);  
   
     // preserve message key     // preserve message key
     response->setKey(request->getKey());     response->setKey(request->getKey());
  
Line 2682 
Line 2462 
     response->setHttpMethod (request->getHttpMethod ());     response->setHttpMethod (request->getHttpMethod ());
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
   
     return(response);     return(response);
 } }
  
 Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw()  Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest");
  
Line 2717 
Line 2496 
     return(response);     return(response);
 } }
  
   Message *
   DefaultProviderManager::handleSubscriptionInitCompleteRequest
       (const Message * message)
   {
       PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
        "DefaultProviderManager::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 <Provider *> 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
               //
               OpProviderHolder ph = providerManager.getProvider(
                   enableProviders[i]->getModule()->getFileName(),
                   enableProviders[i]->getName());
   
               _callEnableIndications (provider, _indicationCallback, ph);
           }
           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);
   }
   
 void DefaultProviderManager::_insertEntry ( void DefaultProviderManager::_insertEntry (
     const Provider & provider,     const Provider & provider,
     const EnableIndicationsResponseHandler *handler)     const EnableIndicationsResponseHandler *handler)
 { {
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,      PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
         "DefaultProviderManager::_insertEntry");         "DefaultProviderManager::_insertEntry");
  
     String tableKey = _generateKey     String tableKey = _generateKey
Line 2735 
Line 2583 
 EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry( EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry(
     const String & key)     const String & key)
 { {
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,      PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
         "DefaultProviderManager::_removeEntry");         "DefaultProviderManager::_removeEntry");
     EnableIndicationsResponseHandler *ret = 0;     EnableIndicationsResponseHandler *ret = 0;
  
     _responseTable.lookup(key, ret);     _responseTable.lookup(key, ret);
       _responseTable.remove(key);         // why is this needed ? - we get killed when removed...
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  
Line 2751 
Line 2600 
 { {
     String tableKey;     String tableKey;
  
     PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,      PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
         "DefaultProviderManager::_generateKey");         "DefaultProviderManager::_generateKey");
  
     //     //
Line 2767 
Line 2616 
     return(tableKey);     return(tableKey);
 } }
  
 ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName)  String DefaultProviderManager::_generateKey (
       const String & providerName,
       const String & providerFileName)
   {
       String tableKey;
   
       PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
                         "DefaultProviderManagerService::_generateKey");
   
       //
       //  Append providerName and providerFileName to key
       //
       tableKey.append (providerName);
       tableKey.append (providerFileName);
   
       PEG_METHOD_EXIT ();
       return tableKey;
   }
   
   ProviderName DefaultProviderManager::_resolveProviderName(
       const ProviderIdContainer & providerId)
   {
       String providerName;
       String fileName;
       String interfaceName;
       CIMValue genericValue;
   
       genericValue = providerId.getProvider().getProperty(
           providerId.getProvider().findProperty("Name")).getValue();
       genericValue.get(providerName);
   
       genericValue = providerId.getModule().getProperty(
           providerId.getModule().findProperty("Location")).getValue();
       genericValue.get(fileName);
       fileName = _resolvePhysicalName(fileName);
   
       // ATTN: This attribute is probably not required
       genericValue = providerId.getModule().getProperty(
           providerId.getModule().findProperty("InterfaceType")).getValue();
       genericValue.get(interfaceName);
   
       return ProviderName(providerName, fileName, interfaceName, 0);
   }
   
   Boolean DefaultProviderManager::hasActiveProviders()
   {
       return providerManager.hasActiveProviders();
   }
   
   void DefaultProviderManager::unloadIdleProviders()
   {
       providerManager.unloadIdleProviders();
   }
   
   void DefaultProviderManager::_callEnableIndications
       (CIMInstance & req_provider,
        PEGASUS_INDICATION_CALLBACK _indicationCallback,
        OpProviderHolder & ph)
   {
       PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
           "DefaultProviderManager::_callEnableIndications");
   
       try
 { {
     ProviderName temp = findProvider(providerName);          CIMRequestMessage * request = 0;
           CIMResponseMessage * response = 0;
           EnableIndicationsResponseHandler * enableHandler =
               new EnableIndicationsResponseHandler
                   (request, response, req_provider, _indicationCallback);
   
           PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Calling provider.enableIndications: " +
               ph.GetProvider ().getName ());
   
           pm_service_op_lock op_lock (& ph.GetProvider ());
           ph.GetProvider ().protect ();
           ph.GetProvider ().enableIndications (* enableHandler);
   
           //
           //  Store the handler so it is persistent for as
           //  long as the provider has indications enabled
           //
           PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
               "Storing indication handler for " +
               ph.GetProvider ().getName ());
  
     String physicalName = temp.getPhysicalName();          _insertEntry (ph.GetProvider (), enableHandler);
       }
       catch (CIMException & e)
       {
           PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
               "CIMException: " + e.getMessage ());
  
     // fully qualify physical provider name (module), if not already done so.          Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
     #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)              "ProviderManager.Default.DefaultProviderManager."
     physicalName = physicalName + String(".dll");                  "ENABLE_INDICATIONS_FAILED",
     #elif defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_IA86_GNU)              "Failed to enable indications for provider $0: $1.",
     String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));              ph.GetProvider ().getName (), e.getMessage ());
     physicalName = root + String("/lib") + physicalName + String(".so");      }
     #elif defined(PEGASUS_OS_HPUX)      catch (Exception & e)
     String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));      {
     physicalName = root + String("/lib") + moduleLocation + String(".sl");          PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
     #elif defined(PEGASUS_OS_OS400)              "Exception: " + e.getMessage ());
     // do nothing  
     #else  
     String root = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));  
     physicalName = root + String("/lib") + physicalName + String(".so");  
  
     #endif          Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
               "ProviderManager.Default.DefaultProviderManager."
                   "ENABLE_INDICATIONS_FAILED",
               "Failed to enable indications for provider $0: $1.",
               ph.GetProvider ().getName (), e.getMessage ());
       }
       catch(...)
       {
           PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
               "Unexpected error in _callEnableIndications");
  
     temp.setPhysicalName(physicalName);          Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
               "ProviderManager.Default.DefaultProviderManager."
                   "ENABLE_INDICATIONS_FAILED_UNKNOWN",
               "Failed to enable indications for provider $0.",
               ph.GetProvider ().getName ());
       }
  
     return(temp);      PEG_METHOD_EXIT ();
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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