(file) Return to ProviderRegistrationProvider.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ControlProviders / ProviderRegistrationProvider

Diff for /pegasus/src/Pegasus/ControlProviders/ProviderRegistrationProvider/ProviderRegistrationProvider.cpp between version 1.91 and 1.107

version 1.91, 2006/09/27 20:13:20 version 1.107, 2008/08/29 09:22:32
Line 28 
Line 28 
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 //  
 // Author: Yi Zhou (yi_zhou@hp.com)  
 //  
 // Modified By: Chip Vincent (cvincent@us.ibm.com)  
 //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //              Seema Gupta (gseema@in.ibm.com) for PEP135  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "ProviderRegistrationProvider.h" #include "ProviderRegistrationProvider.h"
Line 50 
Line 40 
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/MessageLoader.h> //l10n #include <Pegasus/Common/MessageLoader.h> //l10n
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/CIMNameUnchecked.h>
   
   #include <Pegasus/Server/ProviderRegistrationManager/ProviderManagerMap.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 80 
Line 74 
 { {
 } }
  
 void ProviderRegistrationProvider::initialize(CIMOMHandle & cimom)  
 {  
     // This method should not be called because this is a control provider  
     // and is not dynamically loaded through the provider manager  
 }  
   
 void ProviderRegistrationProvider::terminate(void)  
 {  
   // delete self. this is necessary because the entry point for this object allocated it, and  
   // the module is responsible for its memory management.  
   delete this;  
 }  
   
 // get registered provider // get registered provider
 void ProviderRegistrationProvider::getInstance( void ProviderRegistrationProvider::getInstance(
     const OperationContext & context,     const OperationContext & context,
Line 126 
Line 107 
  
     CIMInstance instance;     CIMInstance instance;
  
     try      instance = _providerRegistrationManager->getInstance(
     {          instanceReference, includeQualifiers, includeClassOrigin, propertyList);
         instance = _providerRegistrationManager->getInstance(instanceReference,  
                                                              includeQualifiers,  
                                                              includeClassOrigin,  
                                                              propertyList);  
     }  
     catch(const CIMException&)  
     {  
         throw;  
     }  
  
     handler.deliver(instance);     handler.deliver(instance);
  
Line 176 
Line 148 
  
     Array<CIMInstance> enumInstances;     Array<CIMInstance> enumInstances;
  
     try  
     {  
         enumInstances =         enumInstances =
             _providerRegistrationManager->enumerateInstancesForClass(             _providerRegistrationManager->enumerateInstancesForClass(
                 classReference,                 classReference,
                 includeQualifiers,                 includeQualifiers,
                 includeClassOrigin,                 includeClassOrigin,
                 propertyList);                 propertyList);
     }  
     catch(const CIMException&)  
     {  
         throw;  
     }  
  
     handler.deliver(enumInstances);     handler.deliver(enumInstances);
  
Line 226 
Line 191 
     Array<CIMObjectPath> enumInstanceNames;     Array<CIMObjectPath> enumInstanceNames;
  
     // get all instance names from repository     // get all instance names from repository
     try  
     {  
         enumInstanceNames =         enumInstanceNames =
             _providerRegistrationManager->enumerateInstanceNamesForClass(             _providerRegistrationManager->enumerateInstanceNamesForClass(
                 classReference);                 classReference);
     }  
     catch(const CIMException&)  
     {  
         throw;  
     }  
  
     handler.deliver(enumInstanceNames);     handler.deliver(enumInstanceNames);
  
Line 266 
Line 224 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,  
             //"You must have superuser privilege to modify the registration.");  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(
                         "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_MODIFY_REGISTRATION",              "ControlProviders.ProviderRegistrationProvider."
                         "You must have superuser privilege to modify the registration."));                  "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_MODIFY_REGISTRATION",
               "You must have superuser privilege to modify the"
                   " registration."));
     }     }
   #endif
  
     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
Line 298 
Line 258 
     //     //
     if (propertyList.isNull())     if (propertyList.isNull())
     {     {
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,  
             //"Only can modify Namespaces, SupportedProperties, and SupportedMethods.");  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(
                         "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.CAN_ONLY_MODIFY_ERR",              "ControlProviders.ProviderRegistrationProvider."
                         "Only can modify Namespaces, SupportedProperties, and SupportedMethods."));                  "ProviderRegistrationProvider."
               "CAN_ONLY_MODIFY_ERR",
               "Only can modify Namespaces, SupportedProperties,"
                   "and SupportedMethods."));
     }     }
  
     Array<CIMName> propertyArray = propertyList.getPropertyNameArray();     Array<CIMName> propertyArray = propertyList.getPropertyNameArray();
Line 321 
Line 281 
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     try      _providerRegistrationManager->modifyInstance(
     {          instanceReference, instanceObject, includeQualifiers, propertyArray);
         _providerRegistrationManager->modifyInstance(instanceReference,  
                                                      instanceObject,  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
                                                      includeQualifiers,      _sendUpdateCacheMessagetoInteropProvider(context);
                                                      propertyArray);  #endif
     }  
     catch(const CIMException&)  
     {  
         throw;  
     }  
  
     // complete processing the request     // complete processing the request
     handler.complete();     handler.complete();
Line 356 
Line 311 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,  
             //"You must have superuser privilege to register providers.");  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(
                                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_REGISTER_PROVIDERS",              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_REGISTER_PROVIDERS",
                                 "You must have superuser privilege to register providers."));                                 "You must have superuser privilege to register providers."));
     }     }
   #endif
  
     CIMName className = instanceReference.getClassName();     CIMName className = instanceReference.getClassName();
     CIMNamespaceName nameSpace = instanceReference.getNameSpace();     CIMNamespaceName nameSpace = instanceReference.getNameSpace();
Line 402 
Line 358 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing Name which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAME_IN_PG_PROVIDERMODULE",                          "MISSING_NAME_IN_PG_PROVIDERMODULE",
                 "Missing Name which is required property in PG_ProviderModule class."));                      "Missing Name which is required property in "
                           "PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing Vendor which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VENDOR_IN_PG_PROVIDERMODULE",                          "MISSING_VENDOR_IN_PG_PROVIDERMODULE",
                 "Missing Vendor which is required property in PG_ProviderModule class."));                      "Missing Vendor which is required property in"
                           " PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing Version which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VERSION_IN_PG_PROVIDERMODULE",                          "MISSING_VERSION_IN_PG_PROVIDERMODULE",
                 "Missing Version which is required property in PG_ProviderModule class."));                      "Missing Version which is required property in"
                           " PG_ProviderModule class."));
         }         }
  
         Uint32 ifcTypeIndex =         Uint32 ifcTypeIndex =
             instanceObject.findProperty(_PROPERTY_INTERFACETYPE);             instanceObject.findProperty(_PROPERTY_INTERFACETYPE);
         if (ifcTypeIndex == PEG_NOT_FOUND)         if (ifcTypeIndex == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing InterfaceType which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",                          "MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",
                 "Missing InterfaceType which is required property in PG_ProviderModule class."));                      "Missing InterfaceType which is required property in"
                           " PG_ProviderModule class."));
         }         }
         String ifcTypeString;         String ifcTypeString;
         instanceObject.getProperty(ifcTypeIndex).getValue().         instanceObject.getProperty(ifcTypeIndex).getValue().
             get(ifcTypeString);             get(ifcTypeString);
  
         if (ifcTypeString != "C++Default"          String ifcEmptyVersion;
 #ifdef PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER          if (!ProviderManagerMap::instance().
             && ifcTypeString != "CMPI"                  isValidProvMgrIfc(ifcTypeString, ifcEmptyVersion))
 #endif  
 #ifdef PEGASUS_ENABLE_JMPI_PROVIDER_MANAGER  
             && (ifcTypeString != "JMPI")  
             && (ifcTypeString != "JMPIExperimental")  
 #endif  
                 )  
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,                  MessageLoaderParms(
                 //"Unsupported InterfaceType value: \"" + ifcTypeString + "\"");                  "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                      "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACETYPE_VALUE",                      "UNSUPPORTED_INTERFACETYPE_VALUE",
                 "Unsupported InterfaceType value: \"$0\"",ifcTypeString));                 "Unsupported InterfaceType value: \"$0\"",ifcTypeString));
         }         }
  
Line 467 
Line 421 
             instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);             instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);
         if (ifcVersionIndex == PEG_NOT_FOUND)         if (ifcVersionIndex == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing InterfaceVersion which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",                          "MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",
                 "Missing InterfaceVersion which is required property in PG_ProviderModule class."));                      "Missing InterfaceVersion which is required property "
                           "in PG_ProviderModule class."));
         }         }
         String ifcVersionString;         String ifcVersionString;
         instanceObject.getProperty(ifcVersionIndex).getValue().         instanceObject.getProperty(ifcVersionIndex).getValue().
             get(ifcVersionString);             get(ifcVersionString);
         if (  
 #ifdef PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER          if (!ProviderManagerMap::instance().isValidProvMgrIfc(
            (ifcTypeString == "CMPI" &&                      ifcTypeString, ifcVersionString))
             ifcVersionString != "2.0.0") ||          {
 #endif  
 #ifdef PEGASUS_ENABLE_JMPI_PROVIDER_MANAGER  
            (ifcTypeString == "JMPI" &&  
             ifcVersionString != "1.0.0" &&  
             ifcVersionString != "2.0.0" &&  
             ifcVersionString != "2.2.0") ||  
            (ifcTypeString == "JMPIExperimental" &&  
             ifcVersionString != "0.0.1") ||  
 #endif  
            (ifcTypeString == "C++Default" &&  
             ifcVersionString != "2.1.0" &&  
             ifcVersionString != "2.2.0" &&  
             ifcVersionString != "2.3.0" &&  
             ifcVersionString != "2.5.0" &&  
             ifcVersionString != "2.6.0"))  
         {  
                 //l10n 485  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,  
                 //"Unsupported InterfaceVersion value: \"" + ifcVersionString +  
                    // "\"");  
         String unsupported = "InterfaceVersion";         String unsupported = "InterfaceVersion";
         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACEVERSION_VALUE",                  MessageLoaderParms(
                 "Unsupported InterfaceVersion value: \"$0\"",ifcVersionString));                      "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "UNSUPPORTED_INTERFACEVERSION_VALUE",
                       "Unsupported InterfaceVersion value: \"$0\"",
                   ifcVersionString));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing Location which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_LOCATION_IN_PG_PROVIDERMODULE",                          "MISSING_LOCATION_IN_PG_PROVIDERMODULE",
                 "Missing Location which is required property in PG_ProviderModule class."));                      "Missing Location which is required property in"
                           " PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==
Line 541 
Line 481 
  
         if (!userContextValue.isNull())         if (!userContextValue.isNull())
         {         {
 #ifdef PEGASUS_DISABLE_PROV_USERCTXT  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(  
                 "ControlProviders.ProviderRegistrationProvider."  
                     "ProviderRegistrationProvider.USERCONTEXT_UNSUPPORTED",  
                 "The UserContext property in the PG_ProviderModule class is "  
                     "not supported."));  
 #else  
             Uint16 userContext;             Uint16 userContext;
             userContextValue.get(userContext);             userContextValue.get(userContext);
  
             if (!(  #ifdef PEGASUS_DISABLE_PROV_USERCTXT
 # ifndef PEGASUS_DISABLE_PROV_USERCTXT_REQUESTOR              if (userContext != PG_PROVMODULE_USERCTXT_CIMSERVER)
                   (userContext == PG_PROVMODULE_USERCTXT_REQUESTOR) ||              {
 # endif                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
 # ifndef PEGASUS_DISABLE_PROV_USERCTXT_DESIGNATED                      MessageLoaderParms(
                   (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED) ||                          "ControlProviders.ProviderRegistrationProvider."
 # endif                              "ProviderRegistrationProvider."
 # ifndef PEGASUS_DISABLE_PROV_USERCTXT_PRIVILEGED                              "USERCONTEXT_UNSUPPORTED",
                   (userContext == PG_PROVMODULE_USERCTXT_PRIVILEGED) ||                          "The UserContext property in the PG_ProviderModule "
 # endif                              "class is not supported."));
 # ifndef PEGASUS_DISABLE_PROV_USERCTXT_CIMSERVER              }
   #else
               if (!((userContext == PG_PROVMODULE_USERCTXT_REQUESTOR) ||
   #ifndef PEGASUS_OS_ZOS
                   (userContext == PG_PROVMODULE_USERCTXT_CIMSERVER) ||                   (userContext == PG_PROVMODULE_USERCTXT_CIMSERVER) ||
                     (userContext == PG_PROVMODULE_USERCTXT_PRIVILEGED) ||
 # endif # endif
                   0))                    (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)))
             {             {
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                     MessageLoaderParms(                     MessageLoaderParms(
Line 584 
Line 521 
                     instanceObject.getProperty(designatedUserIndex).getValue()                     instanceObject.getProperty(designatedUserIndex).getValue()
                         .isNull())                         .isNull())
                 {                 {
                     throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,                      throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                         MessageLoaderParms(                         MessageLoaderParms(
                             "ControlProviders.ProviderRegistrationProvider."                             "ControlProviders.ProviderRegistrationProvider."
                                 "ProviderRegistrationProvider."                                 "ProviderRegistrationProvider."
Line 613 
Line 550 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",                          "MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",
                 "Missing ProviderModuleName which is required property in PG_ProviderCapabilities class."));                      "Missing ProviderModuleName which is required property in"
                           " PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n 485  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing ProviderName which is required property in PG_ProviderCapabilities class.");  
                 String missing = "ProviderName";                 String missing = "ProviderName";
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  MessageLoaderParms(
                 "Missing ProviderName which is required property in PG_ProviderCapabilities class."));                      "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_PROVIDERNAME_IN_PG_PROVIDERCAPABILITIES",
                       "Missing the required ProviderName property in "
                           "PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing CapabilityID which is required property in PG_ProviderCapabilities class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSINGCAPABILITYID_IN_PG_PROVIDERCAPABILITIES",                          "MISSING_CAPABILITYID_IN_PG_PROVIDERCAPABILITIES",
                 "Missing CapabilityID which is required property in PG_ProviderCapabilities class."));                      "Missing the required CapabilityID property in "
                           "PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing ClassName which is required property in PG_ProviderCapabilities class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",                          "MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",
                 "Missing ClassName which is required property in PG_ProviderCapabilities class."));                      "Missing ClassName which is required property in"
                           " PG_ProviderCapabilities class."));
         }         }
  
         // Validate the Namespaces property         // Validate the Namespaces property
Line 671 
Line 612 
  
         if (namespacesArray.size() == 0)         if (namespacesArray.size() == 0)
         {         {
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                   MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider."                 "ControlProviders.ProviderRegistrationProvider."
                     "ProviderRegistrationProvider."                     "ProviderRegistrationProvider."
                     "MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",                     "MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",
Line 696 
Line 638 
  
         if (providerTypeArray.size() == 0)         if (providerTypeArray.size() == 0)
         {         {
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 MessageLoaderParms(                 MessageLoaderParms(
                     "ControlProviders.ProviderRegistrationProvider."                     "ControlProviders.ProviderRegistrationProvider."
                         "ProviderRegistrationProvider."                         "ProviderRegistrationProvider."
Line 715 
Line 657 
 #endif #endif
                                           )                                           )
             {             {
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                     MessageLoaderParms(                     MessageLoaderParms(
                         "ControlProviders.ProviderRegistrationProvider."                         "ControlProviders.ProviderRegistrationProvider."
                             "ProviderRegistrationProvider.UNSUPPORTED_"                             "ProviderRegistrationProvider.UNSUPPORTED_"
Line 736 
Line 678 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
 //L10N_ TODO DONE  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_MODULE_NAME_WHICH_IS_REQUIRED",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");                      "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_MODULE_NAME_WHICH_IS_REQUIRED",
                   "Missing ProviderModuleName which is required property in"
                       " PG_ConsumerCapabilities class.");
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
 //L10N_ TODO DONE  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing ProviderName which is required property in PG_ConsumerCapabilities class.");  
  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_NAME_WHICH_IS_REQUIRED",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing ProviderName which is required property in PG_ConsumerCapabilities class.");                      "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_NAME_WHICH_IS_REQUIRED",
                   "Missing ProviderName which is required property in"
                       " PG_ConsumerCapabilities class.");
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
 //L10N_ TODO DONE  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");  
  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CAPABILITY_ID_WHICH_IS_REQUIRED",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");                      "ProviderRegistrationProvider."
                       "MISSING_CAPABILITY_ID_WHICH_IS_REQUIRED",
                   "Missing the required CapabilityID property in "
                       "PG_ConsumerCapabilities class.");
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)          if (instanceObject.findProperty
               (_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)
         {         {
 //L10N_ TODO DONE  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing ProviderType which is required property in PG_ConsumerCapabilities class.");  
  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_TYPE_WHICH_IS_REQUIRED",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing ProviderType which is required property in PG_ConsumerCapabilities class.");                      "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_TYPE_WHICH_IS_REQUIRED",
                   "Missing ProviderType which is required property in"
                       " PG_ConsumerCapabilities class.");
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_INDICATIONDESTINATIONS) ==         if (instanceObject.findProperty(_PROPERTY_INDICATIONDESTINATIONS) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
 //L10N_ TODO DONE  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing Destinations which is required property in PG_ConsumerCapabilities class.");  
  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_DESTINATIONS_TYPE_WHICH_IS_REQUIRED",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing Destinations which is required property in PG_ConsumerCapabilities class.");                      "ProviderRegistrationProvider."
                       "MISSING_DESTINATIONS_TYPE_WHICH_IS_REQUIRED",
                   "Missing Destinations which is required property in"
                       " PG_ConsumerCapabilities class.");
  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
     }     }
     else // PEGASUS_CLASSNAME_PROVIDER     else // PEGASUS_CLASSNAME_PROVIDER
Line 806 
Line 749 
         //         //
         // Name and ProviderModuleName properties must be set         // Name and ProviderModuleName properties must be set
         //         //
         if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)          if (instanceObject.findProperty
                   (PEGASUS_PROPERTYNAME_NAME) == PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing Name which is required property in PG_Provider class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                          "MISSING_NAME_IN_PG_PROVIDER",
                 "Missing Name which is required property in PG_Provider class."));                      "Missing the required Name property in PG_Provider "
                           "class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 //"Missing ProviderModuleName which is required property in PG_Provider class.");                      "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",                          "MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",
                 "Missing ProviderModuleName which is required property in PG_Provider class."));                      "Missing ProviderModuleName which is required property in "
                           "PG_Provider class."));
         }         }
     }     }
  
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     try      returnReference = _providerRegistrationManager->createInstance(
     {          instanceReference, instance);
         returnReference =  
             _providerRegistrationManager->createInstance(instanceReference, instance);  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
     }      if(className.equal (PEGASUS_CLASSNAME_PROVIDER) ||
     catch(const CIMException&)         className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
         throw;          _sendUpdateCacheMessagetoInteropProvider(context);
     }     }
   #endif
  
     handler.deliver(returnReference);     handler.deliver(returnReference);
  
Line 865 
Line 812 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         //l10n  
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,  
             //"You must have superuser privilege to unregister providers.");  
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_UNREGISTER_PROVIDERS",              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_UNREGISTER_PROVIDERS",
             "You must have superuser privilege to unregister providers."));             "You must have superuser privilege to unregister providers."));
     }     }
   #endif
  
     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
Line 882 
Line 830 
     }     }
  
  
 // l10n  
     // Get the client's list of preferred languages for the response  
     AcceptLanguageList al;     AcceptLanguageList al;
     try     try
     {     {
         AcceptLanguageListContainer al_container =         AcceptLanguageListContainer al_container =
                 (AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);                  (AcceptLanguageListContainer)context.get
                   (AcceptLanguageListContainer::NAME);
         al = al_container.getLanguages();         al = al_container.getLanguages();
     }     }
     catch (...)     catch (...)
Line 935 
Line 882 
         // if _PROPERTY_PROVIDERMODULENAME key not found         // if _PROPERTY_PROVIDERMODULENAME key not found
         if( !moduleFound)         if( !moduleFound)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,                      MessageLoaderParms(
                 //"key ProviderModuleName was not found");                  "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                      "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.PROVIDERMODULENAME_KEY_NOT_FOUND",                      "PROVIDERMODULENAME_KEY_NOT_FOUND",
                 "key ProviderModuleName was not found"));                 "key ProviderModuleName was not found"));
         }         }
  
         //         //
         // disable the provider         // disable the provider
         //         //
         try          Sint16 ret_value = _disableModule(
         {              instanceReference, moduleName, true, al);
              Sint16 ret_value = _disableModule(instanceReference, moduleName, true, al);  
  
              //              //
              // if the provider disable failed              // if the provider disable failed
              //              //
 // l10n  
              if (ret_value == -1)              if (ret_value == -1)
              {              {
                 //l10n              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                  //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                      //"disable the provider failed.");                      "ControlProviders.ProviderRegistrationProvider."
                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                                         "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED",                          "DISABLE_PROVIDER_FAILED",
                     "disable the provider failed."));                     "disable the provider failed."));
              }              }
   
              //              //
              // The provider disable failed since there are pending requests              // The provider disable failed since there are pending requests
              //              //
              if (ret_value == -2)              if (ret_value == -2)
              {              {
 //L10N TODO              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                 // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                      //"disable the provider failed: Provider is busy.");                      "ControlProviders.ProviderRegistrationProvider."
                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                                         "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED_PROVIDER_BUSY",                          "DISABLE_PROVIDER_FAILED_PROVIDER_BUSY",
                     "disable the provider failed: Provider is busy."));                     "disable the provider failed: Provider is busy."));
              }              }
         }         }
         catch(CIMException&)  
         {  
             throw;  
         }  
     }  
  
     //     //
     // disable provider module before remove provider registration     // disable provider module before remove provider registration
Line 1003 
Line 944 
         // if _PROPERTY_PROVIDERMODULE_NAME key not found         // if _PROPERTY_PROVIDERMODULE_NAME key not found
         if( !moduleFound)         if( !moduleFound)
         {         {
                 //l10n 485              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,                  MessageLoaderParms(
                 //"key Name was not found");                  "ControlProviders.ProviderRegistrationProvider."
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                  "ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",  
                 "key Name was not found"));                 "key Name was not found"));
         }         }
  
         //         //
         // disable the provider module         // disable the provider module
         //         //
         try          Sint16 ret_value = _disableModule(
         {              instanceReference, moduleName, false, al);
             Sint16 ret_value = _disableModule(instanceReference, moduleName, false, al);  
  
             //             //
             // if the provider module disable failed             // if the provider module disable failed
             //             //
 // l10n  
             if (ret_value == -1)             if (ret_value == -1)
             {             {
                 //l10n              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                  //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                      //"disable the provider module failed.");                      "ControlProviders.ProviderRegistrationProvider."
                      throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                                                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED",                          "DISABLE_PROVIDER_MODULE_FAILED",
                         "disable the provider module failed."));                         "disable the provider module failed."));
             }             }
  
             //             //
             // The provider module disable failed since there are pending requests          // The provider module disable failed since there are
           // pending requests
             //             //
             if (ret_value == -2)             if (ret_value == -2)
             {             {
 //L10N TODO              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                  //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                     // "disable the provider module failed: Provider is busy.");                      "ControlProviders.ProviderRegistrationProvider."
                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                          "ProviderRegistrationProvider."
                                                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED_PROVIDER_BUSY",                          "DISABLE_PROVIDER_MODULE_FAILED_PROVIDER_BUSY",
                         "disable the provider module failed: Provider is busy."));                         "disable the provider module failed: Provider is busy."));
             }             }
         }         }
         catch(const CIMException&)  
         {  
             throw;  
         }  
     }  
  
     try  
     {  
         _providerRegistrationManager->deleteInstance(instanceReference);         _providerRegistrationManager->deleteInstance(instanceReference);
     }  
     catch(const CIMException&)  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
       if(className.equal (PEGASUS_CLASSNAME_PROVIDER) ||
          className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) ||
          className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw;          _sendUpdateCacheMessagetoInteropProvider(context);
     }     }
   #endif
     // complete processing the request     // complete processing the request
     handler.complete();     handler.complete();
 } }
Line 1084 
Line 1019 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         //l10n          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,              MessageLoaderParms(
             //"You must have superuser privilege to disable or enable providers.");              "ControlProviders.ProviderRegistrationProvider."
             throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(                  "ProviderRegistrationProvider."
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_DISABLE_ENABLE_PROVIDERS",                  "SUPERUSER_PRIVILEGE_REQUIRED_DISABLE_ENABLE_PROVIDERS",
             "You must have superuser privilege to disable or enable providers."));              "You must have superuser privilege to disable or enable"
                   " providers."));
     }     }
   #endif
  
     if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))     if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
Line 1107 
Line 1045 
     try     try
     {     {
         AcceptLanguageListContainer al_container =         AcceptLanguageListContainer al_container =
                 (AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);                  (AcceptLanguageListContainer)context.get
                   (AcceptLanguageListContainer::NAME);
         al = al_container.getLanguages();         al = al_container.getLanguages();
     }     }
     catch (...)     catch (...)
Line 1133 
Line 1072 
     // if _PROPERTY_PROVIDERMODULE_NAME key not found     // if _PROPERTY_PROVIDERMODULE_NAME key not found
     if( !moduleFound)     if( !moduleFound)
     {     {
         //l10n 485          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(              MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",                  "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                 "key Name was not found"));                 "key Name was not found"));
     }     }
  
Line 1143 
Line 1083 
  
     Sint16 ret_value;     Sint16 ret_value;
  
     try  
     {  
         if(methodName.equal(_STOP_PROVIDER))         if(methodName.equal(_STOP_PROVIDER))
         {         {
             // disable module             // disable module
Line 1157 
Line 1095 
         }         }
         else         else
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE,
         }              String::EMPTY);
     }  
     catch(const CIMException&)  
     {  
         throw;  
     }     }
   #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
       _sendUpdateCacheMessagetoInteropProvider(context);
   #endif
  
     CIMValue retValue(ret_value);     CIMValue retValue(ret_value);
     handler.deliver(retValue);     handler.deliver(retValue);
Line 1173 
Line 1110 
 // get provider manager service // get provider manager service
 MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService() MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()
 { {
     MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);      MessageQueue * queue =
           MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);
     MessageQueueService * _service = dynamic_cast<MessageQueueService *>(queue);     MessageQueueService * _service = dynamic_cast<MessageQueueService *>(queue);
  
     return(_service);     return(_service);
 } }
  
 ProviderRegistrationProvider & ProviderRegistrationProvider::operator=(const ProviderRegistrationProvider & handle)  ProviderRegistrationProvider & ProviderRegistrationProvider::operator=
       (const ProviderRegistrationProvider & handle)
 { {
     if(this == &handle)     if(this == &handle)
     {     {
Line 1189 
Line 1128 
     return(*this);     return(*this);
 } }
  
 Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(  Array<Uint16>
       ProviderRegistrationProvider::_sendDisableMessageToProviderManager(
         CIMDisableModuleRequestMessage * disable_req)         CIMDisableModuleRequestMessage * disable_req)
 { {
     MessageQueueService * _service = _getProviderManagerService();     MessageQueueService * _service = _getProviderManagerService();
Line 1207 
Line 1147 
         _controller->ClientSendWait(_queueId, asyncRequest);         _controller->ClientSendWait(_queueId, asyncRequest);
     CIMDisableModuleResponseMessage * response =     CIMDisableModuleResponseMessage * response =
         reinterpret_cast<CIMDisableModuleResponseMessage *>(         reinterpret_cast<CIMDisableModuleResponseMessage *>(
              (dynamic_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());               (dynamic_cast<AsyncLegacyOperationResult
                     *>(asyncReply))->get_result());
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)     if (response->cimException.getCode() != CIM_ERR_SUCCESS)
     {     {
         CIMException e = response->cimException;         CIMException e = response->cimException;
Line 1244 
Line 1185 
         _controller->ClientSendWait(_queueId, asyncRequest);         _controller->ClientSendWait(_queueId, asyncRequest);
     CIMEnableModuleResponseMessage * response =     CIMEnableModuleResponseMessage * response =
         reinterpret_cast<CIMEnableModuleResponseMessage *>(         reinterpret_cast<CIMEnableModuleResponseMessage *>(
              (dynamic_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());               (dynamic_cast<AsyncLegacyOperationResult
                     *>(asyncReply))->get_result());
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)     if (response->cimException.getCode() != CIM_ERR_SUCCESS)
     {     {
         CIMException e = response->cimException;         CIMException e = response->cimException;
Line 1486 
Line 1428 
         }         }
         else         else
         {         {
             instance = _providerRegistrationManager->getInstance(objectReference);              instance =
                   _providerRegistrationManager->getInstance(objectReference);
             if (_isIndicationProvider(moduleName, instance))             if (_isIndicationProvider(moduleName, instance))
             {             {
                 indProvider = true;                 indProvider = true;
Line 1517 
Line 1460 
                     indicationProviders,                     indicationProviders,
                     QueueIdStack(_service->getQueueId()));                     QueueIdStack(_service->getQueueId()));
 // l10n // l10n
                 disable_req->operationContext.set(AcceptLanguageListContainer(al));;                  disable_req->operationContext.set
                       (AcceptLanguageListContainer(al));;
  
             Array<Uint16> _opStatus =             Array<Uint16> _opStatus =
                 _sendDisableMessageToProviderManager(disable_req);                 _sendDisableMessageToProviderManager(disable_req);
Line 1532 
Line 1476 
                         if (indProvider)                         if (indProvider)
                         {                         {
                             // send termination message to subscription service                             // send termination message to subscription service
                             _sendTerminationMessageToSubscription(objectReference,                              _sendTerminationMessageToSubscription(
                                   moduleName, false, al);                                  objectReference, moduleName, false, al);
                         }                         }
                         return (0);                         return (0);
                     }                     }
Line 1611 
Line 1555 
                     XmlWriter::getNextMessageId (),                     XmlWriter::getNextMessageId (),
                     mInstance,                     mInstance,
                     QueueIdStack(_service->getQueueId()));                     QueueIdStack(_service->getQueueId()));
 // l10n  
         enable_req->operationContext.set(AcceptLanguageListContainer(al));;              enable_req->operationContext.set(AcceptLanguageListContainer(al));
  
             Array<Uint16> _opStatus;             Array<Uint16> _opStatus;
             _opStatus = _sendEnableMessageToProviderManager(enable_req);             _opStatus = _sendEnableMessageToProviderManager(enable_req);
Line 1635 
Line 1579 
             CIMInstance updatedModuleInstance =             CIMInstance updatedModuleInstance =
                 _providerRegistrationManager->getInstance(moduleRef);                 _providerRegistrationManager->getInstance(moduleRef);
  
             // module is enabled, initialize providers as necessary  
             _providerRegistrationManager->initializeProviders(  
                 updatedModuleInstance);  
   
             //             //
             // The module is enabled, need to send enable message to             // The module is enabled, need to send enable message to
             // subscription service if the provider is an indication provider             // subscription service if the provider is an indication provider
Line 1679 
Line 1619 
                     //                     //
                     // get provider name from reference                     // get provider name from reference
                     //                     //
                     if(keys[j].getName().equal (_PROPERTY_PROVIDER_NAME))                      if(keys[j].getName().equal (PEGASUS_PROPERTYNAME_NAME))
                     {                     {
                         _providerName = keys[j].getValue();                         _providerName = keys[j].getValue();
                     }                     }
Line 1691 
Line 1631 
                     pInstance = _providerRegistrationManager->getInstance                     pInstance = _providerRegistrationManager->getInstance
                         (providerRef);                         (providerRef);
                     //                     //
                     // get all the indication capability instances which belongs                      // get all the indication capability instances which
                     // to this provider                      // belongs to this provider
                     //                     //
                     capInstances = _getIndicationCapInstances(                     capInstances = _getIndicationCapInstances(
                                    moduleName, pInstance, providerRef);                                    moduleName, pInstance, providerRef);
Line 1740 
Line 1680 
                     QueueIdStack(_service->getQueueId()));                     QueueIdStack(_service->getQueueId()));
  
         enable_req->operationContext.set(AcceptLanguageListContainer(al));         enable_req->operationContext.set(AcceptLanguageListContainer(al));
     enable_req->operationContext.insert(ProviderIdContainer(mInstance,pInstance));      enable_req->operationContext.insert(ProviderIdContainer
                                           (mInstance,pInstance));
  
         // create request envelope         // create request envelope
         AsyncLegacyOperationStart * asyncRequest =         AsyncLegacyOperationStart * asyncRequest =
Line 1755 
Line 1696 
  
         CIMNotifyProviderEnableResponseMessage * response =         CIMNotifyProviderEnableResponseMessage * response =
             reinterpret_cast<CIMNotifyProviderEnableResponseMessage *>(             reinterpret_cast<CIMNotifyProviderEnableResponseMessage *>(
                 (dynamic_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());                  (dynamic_cast<AsyncLegacyOperationResult *>
                       (asyncReply))->get_result());
  
         if (response->cimException.getCode() != CIM_ERR_SUCCESS)         if (response->cimException.getCode() != CIM_ERR_SUCCESS)
         {         {
Line 1780 
Line 1722 
 { {
     // get provider name     // get provider name
     String providerName;     String providerName;
     Uint32 pos = instance.findProperty(_PROPERTY_PROVIDER_NAME);      Uint32 pos = instance.findProperty(PEGASUS_PROPERTYNAME_NAME);
     if (pos != PEG_NOT_FOUND)     if (pos != PEG_NOT_FOUND)
     {     {
         instance.getProperty(pos).getValue().get(providerName);         instance.getProperty(pos).getValue().get(providerName);
Line 1800 
Line 1742 
 { {
     // get provider name     // get provider name
     String providerName;     String providerName;
     Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));      Uint32 pos = instance.findProperty(PEGASUS_PROPERTYNAME_NAME);
     if (pos != PEG_NOT_FOUND)     if (pos != PEG_NOT_FOUND)
     {     {
         instance.getProperty(pos).getValue().get(providerName);         instance.getProperty(pos).getValue().get(providerName);
Line 1849 
Line 1791 
             capInstance = _providerRegistrationManager->getInstance             capInstance = _providerRegistrationManager->getInstance
                                 (instanceNames[i]);                                 (instanceNames[i]);
  
             Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));              Uint32 providerTypePos = capInstance.findProperty(
             if (pos != PEG_NOT_FOUND)                  CIMName (_PROPERTY_PROVIDERTYPE));
               if (providerTypePos != PEG_NOT_FOUND)
             {             {
                 capInstance.getProperty(pos).getValue().get(providerTypes);                  capInstance.getProperty(providerTypePos).getValue().get(
                       providerTypes);
  
                 for (Uint32 k=0; k < providerTypes.size(); k++)                 for (Uint32 k=0; k < providerTypes.size(); k++)
                 {                 {
Line 1872 
Line 1816 
     return (indCapInstances);     return (indCapInstances);
 } }
  
   #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
   void ProviderRegistrationProvider::_sendUpdateCacheMessagetoInteropProvider(
       const OperationContext & context)
   {
       String referenceStr("//", 2);
       referenceStr.append(System::getHostName());
       referenceStr.append("/");
       referenceStr.append(PEGASUS_NAMESPACENAME_INTEROP.getString());
       referenceStr.append(":");
       referenceStr.append(
           PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES.getString());
       CIMObjectPath reference(referenceStr);
   
       Array<CIMParamValue> inParams;
       Array<CIMParamValue> outParams;
   
       try
       {
           AutoMutex mtx(_updateMtx);
           _cimomHandle.invokeMethod(
               context,
               PEGASUS_NAMESPACENAME_INTEROP,
               reference,
               CIMNameUnchecked("updateCache"),
               inParams,
               outParams);
       }
       catch(const Exception &e)
       {
           PEG_TRACE((TRC_CONTROLPROVIDER,Tracer::LEVEL1,
               "Exception caught while invoking InteropProvider 'updateCache'"
                   " method: %s",(const char*)e.getMessage().getCString()));
       }
       catch(...)
       {
           PEG_TRACE_CSTRING(
               TRC_CONTROLPROVIDER,
               Tracer::LEVEL1,
               "Unknown error occurred while"
                   " invoking InteropProvider 'updateCache' method.");
       }
   }
   #endif
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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