(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.13 and 1.58

version 1.13, 2002/05/16 00:57:17 version 1.58, 2003/11/04 19:00:59
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
   // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC 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 25 
Line 28 
 // Modified By: Chip Vincent (cvincent@us.ibm.com) // Modified By: Chip Vincent (cvincent@us.ibm.com)
 //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 34 
Line 39 
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
   #include <Pegasus/Common/OperationContext.h>
   #include <Pegasus/Common/System.h>
   #include <Pegasus/Common/MessageLoader.h> //l10n
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 /** /**
    The name of the operational status property  
 */  
 static const char _PROPERTY_OPERATIONALSTATUS [] = "OperationalStatus";  
   
 /**  
    The name of the name property for PG_Provider class  
 */  
 static const char _PROPERTY_PROVIDER_NAME [] = "Name";  
   
 /**  
    The name of the Name property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_PROVIDERMODULE_NAME [] = "Name";  
   
 /**  
    The name of the Vendor property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_VENDOR [] = "Vendor";  
   
 /**  
    The name of the Version property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_VERSION [] = "Version";  
   
 /**  
    The name of the interface type property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_INTERFACETYPE [] = "InterfaceType";  
   
 /**  
    The name of the interface version property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_INTERFACEVERSION [] = "InterfaceVersion";  
   
 /**  
    The name of the location property for PG_ProviderModule class  
 */  
 static const char _PROPERTY_LOCATION [] = "Location";  
   
 /**  
    The name of the CapabilityID property for provider capabilities class    The name of the CapabilityID property for provider capabilities class
 */ */
 static const char _PROPERTY_CAPABILITYID [] = "CapabilityID";  static const CIMName _PROPERTY_CAPABILITYID  = CIMName ("CapabilityID");
   
 /**  
    The name of the provider module name  property for provider capabilities class  
 */  
 static const char _PROPERTY_PROVIDERMODULENAME [] = "ProviderModuleName";  
   
 /**  
    The name of the provider name  property for provider capabilities class  
 */  
 static const char _PROPERTY_PROVIDERNAME [] = "ProviderName";  
   
 /**  
    The name of the classname property for provider capabilities class  
 */  
 static const char _PROPERTY_CLASSNAME [] = "ClassName";  
   
 /**  
    The name of the Namespace property for provider capabilities class  
 */  
 static const char _PROPERTY_NAMESPACES [] = "Namespaces";  
   
 /**  
    The name of the provider type  property for provider capabilities class  
 */  
 static const char _PROPERTY_PROVIDERTYPE [] = "ProviderType";  
   
 /**  
    The name of the supported properties property for provider capabilities class  
 */  
 static const char _PROPERTY_SUPPORTEDPROPERTIES [] = "SupportedProperties";  
   
 /**  
    The name of the supported methods property for provider capabilities class  
 */  
 static const char _PROPERTY_SUPPORTEDMETHODS [] = "SupportedMethods";  
   
 /**  
    Registered instance provider type  
 */  
 static const Uint16 _INSTANCE_PROVIDER    = 2;  
   
 /**  
    Registered association provider type  
 */  
 static const Uint16 _ASSOCIATION_PROVIDER    = 3;  
  
 /** /**
    Registered indication provider type     Module status
 */ */
 static const Uint16 _INDICATION_PROVIDER    = 4;  static const Uint16 _MODULE_OK        = 2;
   
 /**  
    Registered method provider type  
 */  
 static const Uint16 _METHOD_PROVIDER    = 5;  
  
 /** /**
    stopping provider method    stopping provider method
 */ */
 static const char _STOP_PROVIDER[]     = "Stop";  static const CIMName _STOP_PROVIDER     = CIMName ("Stop");
  
 /** /**
    starting provider method    starting provider method
 */ */
 static const char _START_PROVIDER[]   = "Start";  static const CIMName _START_PROVIDER   = CIMName ("Start");
  
 /** /**
    Provider status    Provider status
 */ */
 static const Uint16 _MODULE_UNKNOWN     = 0;  static const Uint16 _MODULE_STOPPING   = 9;
   
 static const Uint16 _MODULE_OK        = 2;  
  
 static const Uint16 _MODULE_STOPPED   = 10; static const Uint16 _MODULE_STOPPED   = 10;
  
Line 164 
Line 80 
  
     _controller = &(ModuleController::get_client_handle(_id, &_client_handle));     _controller = &(ModuleController::get_client_handle(_id, &_client_handle));
     if(_client_handle == NULL)     if(_client_handle == NULL)
       ThrowUninitializedHandle();          throw UninitializedObjectException();
 } }
  
 ProviderRegistrationProvider::~ProviderRegistrationProvider(void) ProviderRegistrationProvider::~ProviderRegistrationProvider(void)
Line 195 
Line 111 
 void ProviderRegistrationProvider::getInstance( void ProviderRegistrationProvider::getInstance(
     const OperationContext & context,     const OperationContext & context,
     const CIMObjectPath & instanceReference,     const CIMObjectPath & instanceReference,
     const Uint32 flags,      const Boolean includeQualifiers,
       const Boolean includeClassOrigin,
     const CIMPropertyList & propertyList,     const CIMPropertyList & propertyList,
     ResponseHandler<CIMInstance> & handler)      InstanceResponseHandler & handler)
 { {
  
     if(!String::equalNoCase(instanceReference.getNameSpace(),      if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
                             PEGASUS_NAMESPACENAME_INTEROP))  
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getNameSpace().getString());
     }     }
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     String className = instanceReference.getClassName();      CIMName className = instanceReference.getClassName();
  
     if(!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))         !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_NOT_SUPPORTED, className);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
Line 240 
Line 159 
 void ProviderRegistrationProvider::enumerateInstances( void ProviderRegistrationProvider::enumerateInstances(
     const OperationContext & context,     const OperationContext & context,
     const CIMObjectPath & classReference,     const CIMObjectPath & classReference,
     const Uint32 flags,      const Boolean includeQualifiers,
       const Boolean includeClassOrigin,
     const CIMPropertyList & propertyList,     const CIMPropertyList & propertyList,
     ResponseHandler<CIMInstance> & handler)      InstanceResponseHandler & handler)
 { {
     if(!String::equalNoCase(classReference.getNameSpace(),      if(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
                             PEGASUS_NAMESPACENAME_INTEROP))  
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, classReference.getNameSpace());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               classReference.getNameSpace().getString());
     }     }
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     String className = classReference.getClassName();      CIMName className = classReference.getClassName();
  
     if(!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))         !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_NOT_SUPPORTED, className);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     Array<CIMNamedInstance> enumInstances;      Array<CIMInstance> enumInstances;
  
     try     try
     {     {
Line 274 
Line 196 
         throw (e);         throw (e);
     }     }
  
     // ATTN: remove when CIMNamedInstance removed.      handler.deliver(enumInstances);
     for(Uint32 i = 0, n = enumInstances.size(); i < n; i++)  
     {  
         handler.deliver(enumInstances[i].getInstance());  
     }  
  
     // complete processing the request     // complete processing the request
     handler.complete();     handler.complete();
Line 288 
Line 206 
 void ProviderRegistrationProvider::enumerateInstanceNames( void ProviderRegistrationProvider::enumerateInstanceNames(
     const OperationContext & context,     const OperationContext & context,
     const CIMObjectPath & classReference,     const CIMObjectPath & classReference,
     ResponseHandler<CIMObjectPath> & handler)      ObjectPathResponseHandler & handler)
 { {
     if(!String::equalNoCase(classReference.getNameSpace(),      if(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
                             PEGASUS_NAMESPACENAME_INTEROP))  
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, classReference.getNameSpace());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               classReference.getNameSpace().getString());
     }     }
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     String className = classReference.getClassName();      CIMName className = classReference.getClassName();
  
     if(!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))         !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_NOT_SUPPORTED, className);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
Line 332 
Line 252 
 // only support to change property of Namespaces, property of // only support to change property of Namespaces, property of
 // SupportedProperties, and property of SupportedMethods // SupportedProperties, and property of SupportedMethods
 void ProviderRegistrationProvider::modifyInstance( void ProviderRegistrationProvider::modifyInstance(
         const OperationContext & _context,          const OperationContext & context,
         const CIMObjectPath & instanceReference,         const CIMObjectPath & instanceReference,
         const CIMInstance & instanceObject,         const CIMInstance & instanceObject,
         const Uint32 flags,          const Boolean includeQualifiers,
         const CIMPropertyList & propertyList,         const CIMPropertyList & propertyList,
         ResponseHandler<CIMInstance> & handler)          ResponseHandler & handler)
   {
       // get userName and only privileged user can execute this operation
       String userName;
       try
       {
           IdentityContainer container = context.get(IdentityContainer::NAME);
           userName = container.getUserName();
       }
       catch (...)
       {
           userName = String::EMPTY;
       }
   
       if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
 { {
     if(!String::equalNoCase(instanceReference.getNameSpace(),          //l10n
                             PEGASUS_NAMESPACENAME_INTEROP))          //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(
                           "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_MODIFY_REGISTRATION",
                           "You must have superuser privilege to modify the registration."));
       }
   
       if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getNameSpace().getString());
     }     }
  
     //     //
     // only support to modify the instance of PG_ProviderCapabilities     // only support to modify the instance of PG_ProviderCapabilities
     //     //
     if (!String::equalNoCase(instanceReference.getClassName(),      if (!instanceReference.getClassName().equal
                              PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))          (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getClassName());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getClassName().getString());
     }     }
  
     //     //
Line 360 
Line 303 
     //     //
     if (propertyList.isNull())     if (propertyList.isNull())
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED,          //l10n
             "Only can modify Namespaces, SupportedProperties, and SupportedMethods.");          //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(
                           "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.CAN_ONLY_MODIFY_ERR",
                           "Only can modify Namespaces, SupportedProperties, and SupportedMethods."));
     }     }
  
     Array<String> propertyArray = propertyList.getPropertyNameArray();      Array<CIMName> propertyArray = propertyList.getPropertyNameArray();
     for (Uint32 i=0; i<propertyArray.size(); i++)     for (Uint32 i=0; i<propertyArray.size(); i++)
     {     {
         if (!String::equalNoCase(propertyArray[i], _PROPERTY_NAMESPACES) &&          if (!propertyArray[i].equal (_PROPERTY_NAMESPACES) &&
             !String::equalNoCase(propertyArray[i], _PROPERTY_SUPPORTEDPROPERTIES) &&              !propertyArray[i].equal (_PROPERTY_SUPPORTEDPROPERTIES) &&
             !String::equalNoCase(propertyArray[i], _PROPERTY_SUPPORTEDMETHODS))              !propertyArray[i].equal (_PROPERTY_SUPPORTEDMETHODS))
         {         {
             throw CIMException (CIM_ERR_NOT_SUPPORTED, propertyArray[i]);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   propertyArray[i].getString());
         }         }
     }     }
  
Line 381 
Line 329 
     try     try
     {     {
         _providerRegistrationManager->modifyInstance(instanceReference,         _providerRegistrationManager->modifyInstance(instanceReference,
             instanceObject, flags, propertyArray);              instanceObject, includeQualifiers, propertyArray);
     }     }
     catch(CIMException& e)     catch(CIMException& e)
     {     {
Line 397 
Line 345 
     const OperationContext & context,     const OperationContext & context,
     const CIMObjectPath & instanceReference,     const CIMObjectPath & instanceReference,
     const CIMInstance & instanceObject,     const CIMInstance & instanceObject,
     ResponseHandler<CIMObjectPath> & handler)      ObjectPathResponseHandler & handler)
   {
       // get userName and only privileged user can execute this operation
       String userName;
       try
       {
           IdentityContainer container = context.get(IdentityContainer::NAME);
           userName = container.getUserName();
       }
       catch (...)
       {
           userName = String::EMPTY;
       }
   
       if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
 { {
     String className = instanceReference.getClassName();          //l10n
     String nameSpace = instanceReference.getNameSpace();          //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(
                                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_REGISTER_PROVIDERS",
                                   "You must have superuser privilege to register providers."));
       }
   
       CIMName className = instanceReference.getClassName();
       CIMNamespaceName nameSpace = instanceReference.getNameSpace();
  
     CIMObjectPath returnReference;     CIMObjectPath returnReference;
  
     CIMInstance instance = instanceObject;     CIMInstance instance = instanceObject;
  
     if(!String::equalNoCase(nameSpace, PEGASUS_NAMESPACENAME_INTEROP))      if(!nameSpace.equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, nameSpace);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               nameSpace.getString());
     }     }
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     if(!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))         !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_NOT_SUPPORTED, className);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     //     //
     // Check all required properties are set     // Check all required properties are set
     //     //
     if(String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))      if (className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         //         //
         // Name, Version, InterfaceType, InterfaceVersion, and Location         // Name, Version, InterfaceType, InterfaceVersion, and Location
         // properties must be set         // properties must be set
         // OperationalStatus property needs to be set. If not, set to default         // OperationalStatus property needs to be set. If not, set to default
         //         //
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULE_NAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==
               PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Name which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAME_IN_PG_PROVIDERMODULE",
                   "Missing Name which is required property in PG_ProviderModule class."));
           }
   
           if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Vendor which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VENDOR_IN_PG_PROVIDERMODULE",
                   "Missing Vendor which is required property in PG_ProviderModule class."));
           }
   
           if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Version which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VERSION_IN_PG_PROVIDERMODULE",
                   "Missing Version which is required property in PG_ProviderModule class."));
           }
   
           Uint32 ifcTypeIndex =
               instanceObject.findProperty(_PROPERTY_INTERFACETYPE);
           if (ifcTypeIndex == PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing InterfaceType which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",
                   "Missing InterfaceType which is required property in PG_ProviderModule class."));
           }
           String ifcTypeString;
           instanceObject.getProperty(ifcTypeIndex).getValue().
               get(ifcTypeString);
   
           if(ifcTypeString != "C++Default" && ifcTypeString != "CMPI" )
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   //"Unsupported InterfaceType value: \"" + ifcTypeString + "\"");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACETYPE_VALUE",
                   "Unsupported InterfaceType value: \"$0\"",ifcTypeString));
           }
   
           Uint32 ifcVersionIndex =
               instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);
           if (ifcVersionIndex == PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing InterfaceVersion which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",
                   "Missing InterfaceVersion which is required property in PG_ProviderModule class."));
           }
           String ifcVersionString;
           instanceObject.getProperty(ifcVersionIndex).getValue().
               get(ifcVersionString);
           if ((ifcVersionString != "2.1.0") &&
               (ifcVersionString != "2.2.0") &&
               (ifcVersionString != "2.3.0"))
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   //"Unsupported InterfaceVersion value: \"" + ifcVersionString +
                      // "\"");
           String unsupported = "InterfaceVersion";
           throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACEVERSION_VALUE",
                   "Unsupported InterfaceVersion value: \"$0\"",ifcVersionString));
           }
   
           if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Location which is required property in PG_ProviderModule class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_LOCATION_IN_PG_PROVIDERMODULE",
                   "Missing Location which is required property in PG_ProviderModule class."));
           }
   
           if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,              Array<Uint16> _operationalStatus;
                 "Missing Name which is required property in PG_ProviderModule class.");              _operationalStatus.append(_MODULE_OK);
               instance.addProperty (CIMProperty
                   (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));
         }         }
       }
       else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
       {
           //
           // ProviderModuleName, ProviderName, InstanceID, ClassName,
           // Namespaces, and ProviderType properties must be set
           //
  
         if (!instanceObject.existsProperty(_PROPERTY_VENDOR))          if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing Vendor which is required property in PG_ProviderModule class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",
                   "Missing ProviderModuleName which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_VERSION))          if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing Version which is required property in PG_ProviderModule class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ProviderName which is required property in PG_ProviderCapabilities class.");
                   String missing = "ProviderName";
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",
                   "Missing ProviderName which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_INTERFACETYPE))          if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing InterfaceType which is required property in PG_ProviderModule class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing CapabilityID which is required property in PG_ProviderCapabilities class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSINGCAPABILITYID_IN_PG_PROVIDERCAPABILITIES",
                   "Missing CapabilityID which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_INTERFACEVERSION))          if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing InterfaceVersion which is required property in PG_ProviderModule class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ClassName which is required property in PG_ProviderCapabilities class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",
                   "Missing ClassName which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_LOCATION))          if (instanceObject.findProperty(_PROPERTY_NAMESPACES) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing Location which is required property in PG_ProviderModule class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Namespaces which is required property in PG_ProviderCapabilities class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",
                   "Missing Namespaces which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_OPERATIONALSTATUS))          if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)
         {         {
             Array<Uint16> _operationalStatus;                  //l10n 485
             _operationalStatus.append(_MODULE_UNKNOWN);              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
             instance.addProperty (CIMProperty                  //"Missing ProviderType which is required property in PG_ProviderCapabilities class.");
                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));                  throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERTYPE_IN_PG_PROVIDERCAPABILITIES",
                   "Missing ProviderType which is required property in PG_ProviderCapabilities class."));
         }         }
     }     }
     else if(String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))      else if (className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES))
     {     {
         //         //
         // ProviderModuleName, ProviderName, InstanceID, ClassName,          // ProviderModuleName, ProviderName, CapabilityID, ProviderType,
         // Namespaces, and ProviderType properties must be set          // and Destinations properties must be set
         //         //
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,  //L10N_ TODO DONE
                 "Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
         }                  //"Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_MODULE_NAME_WHICH_IS_REQUIRED",
                   "Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERNAME))              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
         {  
             throw CIMException (CIM_ERR_FAILED,  
                 "Missing ProviderName which is required property in PG_ProviderCapabilities class.");  
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_CAPABILITYID))          if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,  //L10N_ TODO DONE
                 "Missing CapabilityID which is required property in PG_ProviderCapabilities class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ProviderName which is required property in PG_ConsumerCapabilities class.");
   
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider.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);
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_CLASSNAME))          if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,  //L10N_ TODO DONE
                 "Missing ClassName which is required property in PG_ProviderCapabilities class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");
   
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CAPABILITY_ID_WHICH_IS_REQUIRED",
                   "Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_NAMESPACES))          if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,  //L10N_ TODO DONE
                 "Missing Namespaces which is required property in PG_ProviderCapabilities class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ProviderType which is required property in PG_ConsumerCapabilities class.");
   
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider.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);
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERTYPE))          if (instanceObject.findProperty(_PROPERTY_INDICATIONDESTINATIONS) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_FAILED,  //L10N_ TODO DONE
                 "Missing ProviderType which is required property in PG_ProviderCapabilities class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Destinations which is required property in PG_ConsumerCapabilities class.");
   
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider.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);
         }         }
     }     }
     else // PEGASUS_CLASSNAME_PROVIDER     else // PEGASUS_CLASSNAME_PROVIDER
Line 521 
Line 656 
         //         //
         // Name and ProviderModuleName properties must be set         // Name and ProviderModuleName properties must be set
         //         //
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDER_NAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)
         {  
             throw CIMException (CIM_ERR_FAILED,  
                 "Missing Name which is required property in PG_Provider class.");  
         }  
   
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))  
         {         {
             throw CIMException (CIM_ERR_FAILED,                  //l10n 485
                 "Missing ProviderModuleName which is required property in PG_Provider class.");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing Name which is required property in PG_Provider class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",
                   "Missing Name which is required property in PG_Provider class."));
           }
   
           if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
           {
                   //l10n 485
               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   //"Missing ProviderModuleName which is required property in PG_Provider class.");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",
                   "Missing ProviderModuleName which is required property in PG_Provider class."));
         }         }
     }     }
  
Line 557 
Line 701 
 void ProviderRegistrationProvider::deleteInstance( void ProviderRegistrationProvider::deleteInstance(
     const OperationContext & context,     const OperationContext & context,
     const CIMObjectPath & instanceReference,     const CIMObjectPath & instanceReference,
     ResponseHandler<CIMInstance> & handler)      ResponseHandler & handler)
 { {
     if(!String::equalNoCase(instanceReference.getNameSpace(),      // get userName and only privileged user can execute this operation
                             PEGASUS_NAMESPACENAME_INTEROP))      String userName;
       try
       {
           IdentityContainer container = context.get(IdentityContainer::NAME);
           userName = container.getUserName();
       }
       catch (...)
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());          userName = String::EMPTY;
     }     }
  
     String className = instanceReference.getClassName();      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(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_UNREGISTER_PROVIDERS",
               "You must have superuser privilege to unregister providers."));
       }
  
     // ensure the class existing in the specified namespace      if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     if(!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDER) &&  
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&  
        !String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))  
     {     {
         throw CIMException(CIM_ERR_NOT_SUPPORTED, className);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getNameSpace().getString());
     }     }
  
     // begin processing the request  
     handler.processing();  
  
   // l10n
       // Get the client's list of preferred languages for the response
       AcceptLanguages al = AcceptLanguages::EMPTY;
     try     try
     {     {
         _providerRegistrationManager->deleteInstance(instanceReference);          AcceptLanguageListContainer al_container =
                   (AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);
           al = al_container.getLanguages();
     }     }
     catch(CIMException& e)      catch (...)
     {     {
         throw (e);          ;   // Leave AcceptLanguages empty
     }     }
  
     // complete processing the request      CIMName className = instanceReference.getClassName();
     handler.complete();  
 }  
  
 // Block a provider, unblock a provider, and stop a provider      // ensure the class existing in the specified namespace
 void ProviderRegistrationProvider::invokeMethod(      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
     const OperationContext & context,         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
     const CIMObjectPath & objectReference,         !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
     const String & methodName,         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     const Array<CIMParamValue> & inParameters,  
     Array<CIMParamValue> & outParameters,  
     ResponseHandler<CIMValue> & handler)  
 {  
     if(!String::equalNoCase(objectReference.getNameSpace(),  
                             PEGASUS_NAMESPACENAME_INTEROP))  
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED, objectReference.getNameSpace());          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
       // begin processing the request
       handler.processing();
   
     String moduleName;     String moduleName;
     Boolean moduleFound = false;     Boolean moduleFound = false;
       Array<CIMKeyBinding> keys = instanceReference.getKeyBindings();
  
       //
       // disable provider before delete provider
       // registration if the class is PG_Provider
       //
       if (className.equal (PEGASUS_CLASSNAME_PROVIDER))
       {
     // get module name from reference     // get module name from reference
     Array<KeyBinding> keys = objectReference.getKeyBindings();  
  
     for(Uint32 i=0; i<keys.size() ; i++)     for(Uint32 i=0; i<keys.size() ; i++)
     {     {
         if(String::equalNoCase(keys[i].getName(), _PROPERTY_PROVIDERMODULE_NAME))              if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULENAME))
         {         {
             moduleName = keys[i].getValue();             moduleName = keys[i].getValue();
             moduleFound = true;             moduleFound = true;
         }         }
     }     }
  
     // if _PROPERTY_PROVIDERMODULE_NAME key not found          // if _PROPERTY_PROVIDERMODULENAME key not found
     if( !moduleFound)     if( !moduleFound)
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,                  //l10n 485
                 "key Name was not found");              //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   //"key ProviderModuleName was not found");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.PROVIDERMODULENAME_KEY_NOT_FOUND",
                   "key ProviderModuleName was not found"));
     }     }
  
     //     //
     // get module status          // disable the provider
     //     //
     Array<Uint16> _OperationalStatus =          try
         _providerRegistrationManager->getProviderModuleStatus( moduleName);          {
                Sint16 ret_value = _disableModule(instanceReference, moduleName, true, al);
     handler.processing();  
   
     Sint16 ret_value;  
  
     if(String::equalNoCase(methodName, _STOP_PROVIDER))               //
                // if the provider disable failed
                //
   // l10n
                if (ret_value == -1)
     {     {
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)                  //l10n
                    //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                        //"disable the provider failed.");
                    throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                                           "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED",
                       "disable the provider failed."));
                }
                //
                // The provider disable failed since there are pending requests
                //
                if (ret_value == -2)
         {         {
             // retValue equals 1 if module is already disabled  //L10N TODO
             if (_OperationalStatus[i] == _MODULE_STOPPED)                  // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                        //"disable the provider failed: Provider is busy.");
                    throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                                           "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED_PROVIDER_BUSY",
                       "disable the provider failed: Provider is busy."));
                }
           }
           catch(CIMException&)
             {             {
                 ret_value = 1;              throw;
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }             }
         }         }
  
         CIMInstance mInstance;      //
         CIMInstance instance;      // disable provider module before remove provider registration
         Array<CIMInstance> instances;      // if the class is PG_ProviderModule
         String _moduleName;      //
  
         // get module instance      if (className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
         mInstance = _providerRegistrationManager->getInstance(objectReference);      {
           // get module name from reference
  
         // get all provider instances which have same module name as moduleName          for(Uint32 i=0; i<keys.size() ; i++)
         CIMObjectPath providerRef(objectReference.getHost(),  
                                  objectReference.getNameSpace(),  
                                  PEGASUS_CLASSNAME_PROVIDER,  
                                  objectReference.getKeyBindings());  
         Array<CIMNamedInstance> namedInstances;  
         namedInstances = _providerRegistrationManager->enumerateInstances(providerRef);  
         for(Uint32 i = 0, n=namedInstances.size(); i < n; i++)  
         {  
             instance = namedInstances[i].getInstance();  
             instance.getProperty(instance.findProperty  
             (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);  
             if (String::equalNoCase(_moduleName, moduleName))  
             {             {
                 instances.append(instance);              if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULE_NAME))
               {
                   moduleName = keys[i].getValue();
                   moduleFound = true;
               }
             }             }
  
           // if _PROPERTY_PROVIDERMODULE_NAME key not found
           if( !moduleFound)
           {
                   //l10n 485
           //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   //"key Name was not found");
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                   "key Name was not found"));
         }         }
  
         //         //
         // get provider manager service          // disable the provider module
         //         //
         MessageQueueService * _service = _getProviderManagerService();          try
           {
         // create CIMDisableModuleRequestMessage              Sint16 ret_value = _disableModule(instanceReference, moduleName, false, al);
         CIMDisableModuleRequestMessage * disable_req =  
             new CIMDisableModuleRequestMessage(  
                 XmlWriter::getNextMessageId (),  
                 mInstance,  
                 instances,  
                 QueueIdStack(_service->getQueueId()));  
  
         Array<Uint16> _opStatus =              //
             _sendDisableMessageToProviderManager(disable_req);              // if the provider module disable failed
               //
   // l10n
               if (ret_value == -1)
               {
                   //l10n
                    //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                        //"disable the provider module failed.");
                        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                                                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED",
                           "disable the provider module failed."));
               }
  
         for (Uint32 i = 0; i<_opStatus.size(); i++)              //
               // The provider module disable failed since there are pending requests
               //
               if (ret_value == -2)
         {         {
             if (_opStatus[i] == _MODULE_STOPPED)  //L10N TODO
                    //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                       // "disable the provider module failed: Provider is busy.");
                    throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                                                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED_PROVIDER_BUSY",
                           "disable the provider module failed: Provider is busy."));
               }
           }
           catch(CIMException& e)
             {             {
                 // module was disabled successfully              throw (e);
                 ret_value = 0;          }
                 CIMValue retValue(ret_value);      }
                 handler.deliver(retValue);  
                 handler.complete();  
  
                 // send termination message to subscription service      try
                 _sendTerminationMessageToSubscription(objectReference, moduleName);      {
                 return;          _providerRegistrationManager->deleteInstance(instanceReference);
             }             }
       catch(CIMException& e)
       {
           throw (e);
         }         }
  
         // disable failed      // complete processing the request
         ret_value = -1;  
         CIMValue retValue(ret_value);  
         handler.deliver(retValue);  
         handler.complete();         handler.complete();
         return;  
     }     }
     else if(String::equalNoCase(methodName, _START_PROVIDER))  
     {  // Block a provider, unblock a provider, and stop a provider
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)  void ProviderRegistrationProvider::invokeMethod(
       const OperationContext & context,
       const CIMObjectPath & objectReference,
       const CIMName & methodName,
       const Array<CIMParamValue> & inParameters,
       MethodResultResponseHandler & handler)
         {         {
             // retValue equals 1 if module is already enabled      // get userName and only privileged user can execute this operation
             if (_OperationalStatus[i] == _MODULE_OK)      String userName;
       try
             {             {
                 ret_value = 1;          IdentityContainer container = context.get(IdentityContainer::NAME);
                 CIMValue retValue(ret_value);          userName = container.getUserName();
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }             }
       catch (...)
       {
           userName = String::EMPTY;
         }         }
  
         //      if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
         // get provider manager service      {
         //          //l10n
         MessageQueueService * _service = _getProviderManagerService();          //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
               //"You must have superuser privilege to disable or enable providers.");
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_DISABLE_ENABLE_PROVIDERS",
               "You must have superuser privilege to disable or enable providers."));
       }
  
         // create CIMEnableModuleRequestMessage      if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
         CIMEnableModuleRequestMessage * enable_req =      {
             new CIMEnableModuleRequestMessage(          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                 XmlWriter::getNextMessageId (),              objectReference.getNameSpace().getString());
                 moduleName,      }
                 QueueIdStack(_service->getQueueId()));  
  
         Array<Uint16> _opStatus;  
         _opStatus = _sendEnableMessageToProviderManager(enable_req);  
  
         for (Uint32 i = 0; i<_opStatus.size(); i++)  // l10n
       // Get the client's list of preferred languages for the response
       AcceptLanguages al = AcceptLanguages::EMPTY;
       try
         {         {
             if (_opStatus[i] == _MODULE_OK)          AcceptLanguageListContainer al_container =
                   (AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);
           al = al_container.getLanguages();
       }
       catch (...)
             {             {
                 // module was enabled successfully          ;   // Leave AcceptLanguages empty
                 ret_value = 0;      }
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);      String moduleName;
                 handler.complete();      Boolean moduleFound = false;
                 return;  
       // get module name from reference
       Array<CIMKeyBinding> keys = objectReference.getKeyBindings();
   
       for(Uint32 i=0; i<keys.size() ; i++)
       {
           if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULE_NAME))
           {
               moduleName = keys[i].getValue();
               moduleFound = true;
             }             }
         }         }
  
         // enable failed      // if _PROPERTY_PROVIDERMODULE_NAME key not found
         ret_value = -1;      if( !moduleFound)
         CIMValue retValue(ret_value);      {
         handler.deliver(retValue);          //l10n 485
         handler.complete();          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
         return;                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                   "key Name was not found"));
       }
   
       handler.processing();
   
       Sint16 ret_value;
   
       try
       {
           if(methodName.equal(_STOP_PROVIDER))
           {
               // disable module
                ret_value =  _disableModule(objectReference, moduleName, false, al);
           }
           else if(methodName.equal(_START_PROVIDER))
           {
               // enable module
                ret_value =  _enableModule(objectReference, moduleName, al);
     }     }
     else     else
     {     {
         throw CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);
           }
       }
       catch(CIMException& e)
       {
           throw (e);
     }     }
   
       CIMValue retValue(ret_value);
       handler.deliver(retValue);
       handler.complete();
       return;
 } }
  
 // get provider manager service // get provider manager service
Line 794 
Line 1040 
     return(*this);     return(*this);
 } }
  
 void ProviderRegistrationProvider::async_callback(Uint32 user_data,  
     Message *reply,  
     void *parm)  
 {  
    callback_data *cb_data = reinterpret_cast<callback_data *>(parm);  
    cb_data->reply = reply;  
    cb_data->client_sem.signal();  
 }  
   
 Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager( Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(
         CIMDisableModuleRequestMessage * disable_req)         CIMDisableModuleRequestMessage * disable_req)
 { {
Line 820 
Line 1057 
             disable_req,             disable_req,
             _queueId);             _queueId);
  
 // ATTN-YZ-P2-05032002: Temporarily removed, until asyn_callback fixed  
 /*  
     if( false  == _controller->ClientSendAsync(*_client_handle,  
                                                0,  
                                                _queueId,  
                                                asyncRequest,  
                                                ProviderRegistrationProvider::async_callback,  
                                                (void *)cb_data) )  
     {  
        delete asyncRequest;  
        delete cb_data;  
        throw CIMException(CIM_ERR_NOT_FOUND);  
   
     }  
   
     cb_data->client_sem.wait();  
     AsyncReply * asyncReply = static_cast<AsyncReply *>(cb_data->get_reply()) ;  
   
     CIMDisableModuleResponseMessage * response =  
         reinterpret_cast<CIMDisableModuleResponseMessage *>(  
              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());  
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
     {  
         CIMException e = response->cimException;  
   
         delete asyncRequest;  
         delete asyncReply;  
         delete response;  
         delete cb_data;  
   
         throw (e);  
     }  
   
     Array<Uint16> operationalStatus = response->operationalStatus;  
   
     delete asyncRequest;  
     delete asyncReply;  
     delete response;  
     delete cb_data;  
 */  
   
 // ATTN-YZ-P2-05032002: Temporarily use ClientSendWait, until asyn_callback fixed  
   
     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,
                                                           _queueId,                                                           _queueId,
                                                           asyncRequest);                                                           asyncRequest);
Line 904 
Line 1098 
             enable_req,             enable_req,
             _queueId);             _queueId);
  
 // ATTN-YZ-P2-05032002: Temporarily removed, until asyn_callback fixed  
 /*  
     if( false  == _controller->ClientSendAsync(*_client_handle,  
                                                0,  
                                                _queueId,  
                                                asyncRequest,  
                                                ProviderRegistrationProvider::async_callback,  
                                                (void *)cb_data) )  
     {  
        delete asyncRequest;  
        delete cb_data;  
        throw CIMException(CIM_ERR_NOT_FOUND);  
   
     }  
   
     cb_data->client_sem.wait();  
     AsyncReply * asyncReply = static_cast<AsyncReply *>(cb_data->get_reply()) ;  
   
     CIMEnableModuleResponseMessage * response =  
         reinterpret_cast<CIMEnableModuleResponseMessage *>(  
              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());  
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)  
     {  
         CIMException e = response->cimException;  
         delete asyncRequest;  
         delete asyncReply;  
         delete response;  
         delete cb_data;  
         throw (e);  
     }  
   
     Array<Uint16> operationalStatus = response->operationalStatus;  
   
     delete asyncRequest;  
     delete asyncReply;  
     delete response;  
     delete cb_data;  
 */  
   
 // ATTN-YZ-P2-05032002: Temporarily use ClientSendWait, until asyn_callback fixed  
   
     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,
                                                           _queueId,                                                           _queueId,
                                                           asyncRequest);                                                           asyncRequest);
Line 971 
Line 1124 
  
 // send termination message to subscription service // send termination message to subscription service
 void ProviderRegistrationProvider::_sendTerminationMessageToSubscription( void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(
     const CIMObjectPath & ref, const String & moduleName)      const CIMObjectPath & ref, const String & moduleName,
       const Boolean disableProviderOnly,
       const AcceptLanguages & al)
 { {
     CIMInstance instance;     CIMInstance instance;
     String _moduleName;     String _moduleName;
     Array<CIMInstance> instances;     Array<CIMInstance> instances;
  
       if (!disableProviderOnly)
       {
     CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,     CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,
         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());
  
     // get all registered providers          Array<CIMObjectPath> instanceNames =
     Array<CIMNamedInstance> enumInstances =              _providerRegistrationManager->enumerateInstanceNames(reference);
         _providerRegistrationManager->enumerateInstances(reference);  
  
     // find all the instances which have same module name as moduleName     // find all the instances which have same module name as moduleName
     for (Uint32 i = 0, n=enumInstances.size(); i < n; i++)          for (Uint32 i = 0, n=instanceNames.size(); i < n; i++)
     {     {
         instance = enumInstances[i].getInstance();  
   
         //         //
         // get provider module name              // get provider module name from reference
         //         //
         instance.getProperty(instance.findProperty  
         (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);              Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
               for(Uint32 j=0; j < keys.size(); j++)
               {
                   if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                   {
                       _moduleName = keys[j].getValue();
                   }
               }
  
         if (String::equalNoCase(moduleName, _moduleName))         if (String::equalNoCase(moduleName, _moduleName))
         {         {
                   reference.setKeyBindings(keys);
                   instance = _providerRegistrationManager->getInstance(reference);
                   //
                   // if the provider is indication provider
                   //
                   if (_isIndicationProvider(moduleName, instance, reference))
                   {
                       instances.append(instance);
                   }
               }
           }
       }
       else
       {
           instance = _providerRegistrationManager->getInstance(ref);
   
           //
           // if the provider is indication provider
           //
           if (_isIndicationProvider(moduleName, instance, ref))
           {
             instances.append(instance);             instances.append(instance);
         }         }
     }     }
Line 1005 
Line 1188 
     // get indication server queueId     // get indication server queueId
     //     //
     MessageQueueService * _service = _getIndicationService();     MessageQueueService * _service = _getIndicationService();
   
       if (_service != NULL)
       {
     Uint32 _queueId = _service->getQueueId();     Uint32 _queueId = _service->getQueueId();
  
     CIMNotifyProviderTerminationRequestMessage * termination_req =     CIMNotifyProviderTerminationRequestMessage * termination_req =
Line 1013 
Line 1199 
             instances,             instances,
             QueueIdStack(_service->getQueueId()));             QueueIdStack(_service->getQueueId()));
  
   // l10n
           termination_req->acceptLanguages = al;
   
     // create request envelope     // create request envelope
     AsyncLegacyOperationStart * asyncRequest =     AsyncLegacyOperationStart * asyncRequest =
         new AsyncLegacyOperationStart (         new AsyncLegacyOperationStart (
Line 1028 
Line 1217 
                            asyncRequest))                            asyncRequest))
     {     {
         delete asyncRequest;         delete asyncRequest;
         throw CIMException(CIM_ERR_NOT_FOUND);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);
           }
     }     }
 } }
  
Line 1043 
Line 1233 
     return(_service);     return(_service);
 } }
  
   // disable provider module, return 0 if module is disabled successfully,
   // return 1 if module is already disabled, return -2 if module can not be
   // disabled since there are pending requests, otherwise, return -1
   Sint16 ProviderRegistrationProvider::_disableModule(
       const CIMObjectPath & objectReference,
       const String & moduleName,
       Boolean disableProviderOnly,
       const AcceptLanguages & al)         // l10n
   {
           //
           // get module status
           //
           Array<Uint16> _OperationalStatus =
               _providerRegistrationManager->getProviderModuleStatus( moduleName);
   
           for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
           {
               // retValue equals 1 if module is already disabled
               if (_OperationalStatus[i] == _MODULE_STOPPED ||
                   _OperationalStatus[i] == _MODULE_STOPPING)
               {
                   return (1);
               }
           }
   
           CIMInstance instance;
           Array<CIMInstance> instances;
           CIMInstance mInstance;
           String _moduleName;
           Uint16 providers;
           CIMObjectPath providerRef;
           Boolean indProvider = false;
           Array<Boolean> indicationProviders;
   
           // disable a provider module or delete a provider module
           if (!disableProviderOnly)
           {
               providerRef = CIMObjectPath(objectReference.getHost(),
                                    objectReference.getNameSpace(),
                                    PEGASUS_CLASSNAME_PROVIDER,
                                    objectReference.getKeyBindings());
   
               // get module instance
               mInstance =
                   _providerRegistrationManager->getInstance(objectReference);
   
           }
           else // disable a provider
           {
               // get module instance
               Array <CIMKeyBinding> moduleKeyBindings;
               moduleKeyBindings.append (CIMKeyBinding
                   (_PROPERTY_PROVIDERMODULE_NAME, moduleName,
                    CIMKeyBinding::STRING));
   
               CIMObjectPath moduleRef(objectReference.getHost(),
                                       objectReference.getNameSpace(),
                                       PEGASUS_CLASSNAME_PROVIDERMODULE,
                                       moduleKeyBindings);
   
               mInstance =
                   _providerRegistrationManager->getInstance(moduleRef);
           }
   
           if (!disableProviderOnly)
           {
               // get all provider instances which have same module name as
               // moduleName
               Array<CIMObjectPath> instanceNames =
                   _providerRegistrationManager->enumerateInstanceNames(providerRef);
   
               for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
               {
                   //
                   // get provider module name from reference
                   //
   
                   Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
                   for(Uint32 j=0; j < keys.size(); j++)
                   {
                       if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                       {
                           _moduleName = keys[j].getValue();
                       }
                   }
   
                   if (String::equalNoCase(_moduleName, moduleName))
                   {
                       providerRef.setKeyBindings(keys);
                       instance = _providerRegistrationManager->getInstance
                           (providerRef);
                       if (_isIndicationProvider(moduleName, instance, providerRef))
                       {
                           indProvider = true;
                           indicationProviders.append(true);
                       }
                       else
                       {
                           indicationProviders.append(false);
                       }
                       instances.append(instance);
                   }
   
               }
           }
           else
           {
               instance = _providerRegistrationManager->getInstance(objectReference);
               if (_isIndicationProvider(moduleName, instance, objectReference))
               {
                   indProvider = true;
                   indicationProviders.append(true);
               }
               else
               {
                   indicationProviders.append(false);
               }
   
               instances.append(instance);
           }
   
           //
           // get provider manager service
           //
           MessageQueueService * _service = _getProviderManagerService();
   
           if (_service != NULL)
           {
               // create CIMDisableModuleRequestMessage
               CIMDisableModuleRequestMessage * disable_req =
                   new CIMDisableModuleRequestMessage(
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       instances,
                       disableProviderOnly,
                       indicationProviders,
                       QueueIdStack(_service->getQueueId()));
   // l10n
               disable_req->acceptLanguages = al;
   
               Array<Uint16> _opStatus =
                   _sendDisableMessageToProviderManager(disable_req);
   
               if (!disableProviderOnly) // disable provider module
               {
                   for (Uint32 i = 0; i<_opStatus.size(); i++)
                   {
                       // module was disabled successfully
                       if (_opStatus[i] == _MODULE_STOPPED)
                       {
                           if (indProvider)
                           {
                               // send termination message to subscription service
                               _sendTerminationMessageToSubscription(objectReference,
                                     moduleName, false, al);
                           }
                           return (0);
                       }
   
                       // module is not disabled since there are pending
                       // requests for the providers in the module
                       if (_opStatus[i] == _MODULE_OK)
                       {
                           return (-2);
                       }
                   }
               }
               else // disable provider
               {
                   if (indProvider)
                   {
                       _sendTerminationMessageToSubscription(objectReference,
                           moduleName, true, al);
                   }
                   return (0);
               }
           }
   
           // disable failed
           return (-1);
   }
   
   // enable provider module
   // return 0 if module is enabled successfully,
   // return 1 if module is already enabled,
   // return 2 if module can not be enabled since module is stopping,
   // otherwise, return -1
   Sint16 ProviderRegistrationProvider::_enableModule(
       const CIMObjectPath & moduleRef,
       const String & moduleName,
       const AcceptLanguages & al)
   {
           //
           // get module status
           //
           Array<Uint16> _OperationalStatus =
               _providerRegistrationManager->getProviderModuleStatus( moduleName);
   
           for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
           {
               // retValue equals 1 if module is already enabled
               if (_OperationalStatus[i] == _MODULE_OK)
               {
                   return (1);
               }
   
               // retValue equals 2 if module is stopping
               // at this stage, module can not be started
               if (_OperationalStatus[i] == _MODULE_STOPPING)
               {
                   return (2);
               }
           }
   
           // get module instance
           CIMInstance mInstance =
               _providerRegistrationManager->getInstance(moduleRef);
   
           //
           // get provider manager service
           //
           MessageQueueService * _service = _getProviderManagerService();
           Boolean enabled = false;
   
           if (_service != NULL)
           {
               // create CIMEnableModuleRequestMessage
               CIMEnableModuleRequestMessage * enable_req =
                   new CIMEnableModuleRequestMessage(
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       QueueIdStack(_service->getQueueId()));
   // l10n
               enable_req->acceptLanguages = al;
   
               Array<Uint16> _opStatus;
               _opStatus = _sendEnableMessageToProviderManager(enable_req);
   
               for (Uint32 i = 0; i<_opStatus.size(); i++)
               {
                   // module is enabled successfully
                   if (_opStatus[i] == _MODULE_OK)
                   {
                       enabled = true;
                   }
               }
           }
   
           if (enabled)
           {
               //
               // if the module is enabled, need to send enable message to
               // subscription service if the provider is an indication provider
               //
   
               CIMObjectPath providerRef = CIMObjectPath(String::EMPTY,
                                       moduleRef.getNameSpace(),
                                       PEGASUS_CLASSNAME_PROVIDER,
                                       Array<CIMKeyBinding>());
   
               //
               // get all provider instances which have same module name as
               // moduleName
               //
               Array<CIMObjectPath> instanceNames =
                   _providerRegistrationManager->enumerateInstanceNames(providerRef);
               CIMInstance pInstance;
               String _moduleName;
               String _providerName;
               Array<CIMInstance> capInstances;
   
               for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
               {
   
                   Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
                   for(Uint32 j=0; j < keys.size(); j++)
                   {
                       //
                       // get provider module name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                       {
                           _moduleName = keys[j].getValue();
                       }
   
                       //
                       // get provider name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDER_NAME))
                       {
                           _providerName = keys[j].getValue();
                       }
                   }
   
                   if (String::equalNoCase(_moduleName, moduleName))
                   {
                       providerRef.setKeyBindings(keys);
                       pInstance = _providerRegistrationManager->getInstance
                           (providerRef);
                       //
                       // get all the indication capability instances which belongs
                       // to this provider
                       //
                       capInstances = _getIndicationCapInstances(
                                      moduleName, pInstance, providerRef);
   
                       //
                       // if there are indication capability instances
                       //
                       if (capInstances.size() != 0)
                       {
                           _sendEnableMessageToSubscription(mInstance,
                                                            pInstance,
                                                            capInstances,
                                                            al);
                       }
                   }
               }
               return (0);
           }
   
   
           // enable failed
           return (-1);
   }
   
   // send enable message to indication service
   void ProviderRegistrationProvider::_sendEnableMessageToSubscription(
       const CIMInstance & mInstance,
       const CIMInstance & pInstance,
       const Array<CIMInstance> & capInstances,
       const AcceptLanguages & al)
   {
       //
       // get indication server queueId
       //
       MessageQueueService * _service = _getIndicationService();
   
       if (_service != NULL)
       {
           Uint32 _queueId = _service->getQueueId();
   
           CIMNotifyProviderEnableRequestMessage * enable_req =
                   new CIMNotifyProviderEnableRequestMessage (
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       pInstance,
                       capInstances,
                       QueueIdStack(_service->getQueueId()));
   
           enable_req->acceptLanguages = al;
   
           // create request envelope
           AsyncLegacyOperationStart * asyncRequest =
               new AsyncLegacyOperationStart (
                   _service->get_next_xid(),
                   NULL,
                   _queueId,
                   enable_req,
                   _queueId);
   
           if( false  == _controller->ClientSendForget(
                         *_client_handle,
                         _queueId,
                         asyncRequest))
           {
               delete asyncRequest;
               throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);
           }
   
       }
   }
   
   // If the provider is indication provider, return true,
   // otherwise, return false
   Boolean ProviderRegistrationProvider::_isIndicationProvider(
       const String & moduleName,
       const CIMInstance & instance,
       const CIMObjectPath & providerRef)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       CIMObjectPath capabilityRef;
   
       capabilityRef = CIMObjectPath(providerRef.getHost(),
                                     providerRef.getNameSpace(),
                                     PEGASUS_CLASSNAME_CAPABILITIESREGISTRATION,
                                     providerRef.getKeyBindings());
   
       // get all Capabilities instances
       Array<CIMObjectPath> instanceNames =
           _providerRegistrationManager->enumerateInstanceNames(capabilityRef);
   
       //
       // get provider module name and provider name from capability reference
       //
       String _moduleName, _providerName;
       CIMInstance capInstance;
       Array<Uint16> providerTypes;
       for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
       {
           Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
           for(Uint32 j=0; j < keys.size(); j++)
           {
                if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                {
                     _moduleName = keys[j].getValue();
                }
   
                if(keys[j].getName().equal (_PROPERTY_PROVIDERNAME))
                {
                     _providerName = keys[j].getValue();
                }
   
                //
                // if capability instance has same module name as moduleName
                // and same provider name as providerName, get provider type
                //
                if(String::equal(_moduleName, moduleName) &&
                   String::equal(_providerName, providerName))
                {
                     capInstance = _providerRegistrationManager->getInstance
                                   (instanceNames[i]);
   
                     Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));
                     if (pos != PEG_NOT_FOUND)
                     {
                          capInstance.getProperty(pos).getValue().get(providerTypes);
   
                           for (Uint32 k=0; k < providerTypes.size(); k++)
                           {
                               if (providerTypes[k] == _INDICATION_PROVIDER)
                               {
                                   return (true);
                               }
                           }
                     }
                }
           }
       }
   
       return (false);
   }
   
   //
   // get all the capability instances whose provider type is indication
   //
   Array<CIMInstance> ProviderRegistrationProvider::_getIndicationCapInstances(
       const String & moduleName,
       const CIMInstance & instance,
       const CIMObjectPath & providerRef)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       CIMObjectPath capabilityRef;
   
       capabilityRef = CIMObjectPath(providerRef.getHost(),
                                     providerRef.getNameSpace(),
                                     PEGASUS_CLASSNAME_CAPABILITIESREGISTRATION,
                                     providerRef.getKeyBindings());
   
       // get all Capabilities instances
       Array<CIMObjectPath> instanceNames =
           _providerRegistrationManager->enumerateInstanceNames(capabilityRef);
   
       String _moduleName, _providerName;
       CIMInstance capInstance;
       Array<Uint16> providerTypes;
       Array<CIMInstance> indCapInstances = 0;
       for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
       {
           Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
           for(Uint32 j=0; j < keys.size(); j++)
           {
                if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                {
                     _moduleName = keys[j].getValue();
                }
   
                if(keys[j].getName().equal (_PROPERTY_PROVIDERNAME))
                {
                     _providerName = keys[j].getValue();
                }
           }
   
          //
          // if capability instance has same module name as moduleName
          // and same provider name as providerName, get provider type
          //
          if(String::equal(_moduleName, moduleName) &&
             String::equal(_providerName, providerName))
          {
               capInstance = _providerRegistrationManager->getInstance
                                   (instanceNames[i]);
   
               Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));
               if (pos != PEG_NOT_FOUND)
               {
                   capInstance.getProperty(pos).getValue().get(providerTypes);
   
                   for (Uint32 k=0; k < providerTypes.size(); k++)
                   {
                       //
                       // if provider type of the instance is indication,
                       // append the instance
                       //
                       if (providerTypes[k] == _INDICATION_PROVIDER)
                       {
                           indCapInstances.append(capInstance);
                       }
                   }
               }
           }
       }
   
       return (indCapInstances);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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