(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.51 and 1.84

version 1.51, 2003/09/10 18:36:49 version 1.84, 2006/01/30 16:17:45
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 28 
Line 36 
 //              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 //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                  (carolann_graves@hp.com) //                  (carolann_graves@hp.com)
   //              Seema Gupta (gseema@in.ibm.com) for PEP135
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 46 
 #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/OperationContextInternal.h>
 #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>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 49 
Line 59 
 static const CIMName _PROPERTY_CAPABILITYID  = CIMName ("CapabilityID"); static const CIMName _PROPERTY_CAPABILITYID  = CIMName ("CapabilityID");
  
 /** /**
    Module status  
 */  
 static const Uint16 _MODULE_OK        = 2;  
   
 /**  
    stopping provider method    stopping provider method
 */ */
 static const CIMName _STOP_PROVIDER     = CIMName ("Stop"); static const CIMName _STOP_PROVIDER     = CIMName ("Stop");
Line 63 
Line 68 
 */ */
 static const CIMName _START_PROVIDER   = CIMName ("Start"); static const CIMName _START_PROVIDER   = CIMName ("Start");
  
 /**  
    Provider status  
 */  
 static const Uint16 _MODULE_STOPPING   = 9;  
   
 static const Uint16 _MODULE_STOPPED   = 10;  
   
 ProviderRegistrationProvider::ProviderRegistrationProvider( ProviderRegistrationProvider::ProviderRegistrationProvider(
     ProviderRegistrationManager * providerRegistrationManager)     ProviderRegistrationManager * providerRegistrationManager)
     :_id(peg_credential_types::PROVIDER)     :_id(peg_credential_types::PROVIDER)
Line 83 
Line 81 
  
 ProviderRegistrationProvider::~ProviderRegistrationProvider(void) ProviderRegistrationProvider::~ProviderRegistrationProvider(void)
 { {
     if (_providerRegistrationManager)  
     {  
         delete _providerRegistrationManager;  
     }  
   
     if (_client_handle)     if (_client_handle)
     {     {
         delete _client_handle;         delete _client_handle;
Line 103 
Line 96 
  
 void ProviderRegistrationProvider::terminate(void) 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
Line 140 
Line 136 
  
     try     try
     {     {
         instance = _providerRegistrationManager->getInstance(instanceReference);          instance = _providerRegistrationManager->getInstance(instanceReference,
                                                                includeQualifiers,
                                                                includeClassOrigin,
                                                                propertyList);
     }     }
     catch(CIMException& e)      catch(const CIMException&)
     {     {
         throw (e);          throw;
     }     }
  
     handler.deliver(instance);     handler.deliver(instance);
Line 187 
Line 186 
  
     try     try
     {     {
         enumInstances = _providerRegistrationManager->enumerateInstances(classReference);          enumInstances =
               _providerRegistrationManager->enumerateInstances(classReference,
                                                                includeQualifiers,
                                                                includeClassOrigin,
                                                                propertyList);
     }     }
     catch(CIMException& e)      catch(const CIMException&)
     {     {
         throw (e);          throw;
     }     }
  
     handler.deliver(enumInstances);     handler.deliver(enumInstances);
Line 235 
Line 238 
         enumInstanceNames =         enumInstanceNames =
             _providerRegistrationManager->enumerateInstanceNames(classReference);             _providerRegistrationManager->enumerateInstanceNames(classReference);
     }     }
     catch(CIMException& e)      catch(const CIMException&)
     {     {
         throw (e);          throw;
     }     }
  
     handler.deliver(enumInstanceNames);     handler.deliver(enumInstanceNames);
Line 327 
Line 330 
     try     try
     {     {
         _providerRegistrationManager->modifyInstance(instanceReference,         _providerRegistrationManager->modifyInstance(instanceReference,
             instanceObject, includeQualifiers, propertyArray);                                                       instanceObject,
                                                        includeQualifiers,
                                                        propertyArray);
     }     }
     catch(CIMException& e)      catch(const CIMException& e)
     {     {
         throw (e);          throw;
     }     }
  
     // complete processing the request     // complete processing the request
Line 346 
Line 351 
     ObjectPathResponseHandler & handler)     ObjectPathResponseHandler & handler)
 { {
     // get userName and only privileged user can execute this operation     // get userName and only privileged user can execute this operation
     String PG_ProviderModule_Name = "PG_ProviderModule"; //l10n  
     String PG_ProviderCapabilities_Name = "PG_ProviderCapabilities"; //l10n  
     String PG_Provider_Name = "PG_Provider";  
     String userName;     String userName;
     try     try
     {     {
Line 406 
Line 408 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing Name which is required property in PG_ProviderModule class.");                 //"Missing Name which is required property in PG_ProviderModule class.");
                 String missing = "Name";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAME_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "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                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing Vendor which is required property in PG_ProviderModule class.");                 //"Missing Vendor which is required property in PG_ProviderModule class.");
                 String missing = "Vendor";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VENDOR_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "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                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing Version which is required property in PG_ProviderModule class.");                 //"Missing Version which is required property in PG_ProviderModule class.");
                 String missing = "Version";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VERSION_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "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                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing InterfaceType which is required property in PG_ProviderModule class.");                 //"Missing InterfaceType which is required property in PG_ProviderModule class.");
                 String missing = "InterfaceType";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "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" && ifcTypeString != "CMPI" )          if (ifcTypeString != "C++Default"
   #ifdef PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER
               && ifcTypeString != "CMPI"
   #endif
                   )
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                 //"Unsupported InterfaceType value: \"" + ifcTypeString + "\"");                 //"Unsupported InterfaceType value: \"" + ifcTypeString + "\"");
                 String unsupported = "InterfaceType";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_VALUE",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACETYPE_VALUE",
                 "Unsupported $0 value: \"$1\"",unsupported,ifcTypeString));                  "Unsupported InterfaceType value: \"$0\"",ifcTypeString));
         }         }
  
         Uint32 ifcVersionIndex =         Uint32 ifcVersionIndex =
             instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);             instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);
         if (ifcVersionIndex == PEG_NOT_FOUND)         if (ifcVersionIndex == PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing InterfaceVersion which is required property in PG_ProviderModule class.");                 //"Missing InterfaceVersion which is required property in PG_ProviderModule class.");
                 String missing = "InterfaceVersion";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "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 ((ifcVersionString != "2.1.0") &&          if (
             (ifcVersionString != "2.2.0") &&  #ifdef PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER
             (ifcVersionString != "2.3.0"))             (ifcTypeString == "CMPI" &&
               ifcVersionString != "2.0.0") ||
   #endif
              (ifcTypeString == "C++Default" &&
               ifcVersionString != "2.1.0" &&
               ifcVersionString != "2.2.0" &&
               ifcVersionString != "2.3.0" &&
               ifcVersionString != "2.5.0"))
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                 //"Unsupported InterfaceVersion value: \"" + ifcVersionString +                 //"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,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_VALUE",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACEVERSION_VALUE",
                 "Unsupported $0 value: \"$1\"",unsupported,ifcVersionString));                  "Unsupported InterfaceVersion value: \"$0\"",ifcVersionString));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing Location which is required property in PG_ProviderModule class.");                 //"Missing Location which is required property in PG_ProviderModule class.");
                 String missing = "Location";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_LOCATION_IN_PG_PROVIDERMODULE",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));                  "Missing Location which is required property in PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             Array<Uint16> _operationalStatus;             Array<Uint16> _operationalStatus;
             _operationalStatus.append(_MODULE_OK);              _operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
             instance.addProperty (CIMProperty             instance.addProperty (CIMProperty
                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));
         }         }
   
           //
           // Validate the UserContext property
           //
           CIMValue userContextValue;
           Uint32 userContextIndex = instanceObject.findProperty(
               PEGASUS_PROPERTYNAME_MODULE_USERCONTEXT);
   
           if (userContextIndex != PEG_NOT_FOUND)
           {
               userContextValue =
                   instanceObject.getProperty(userContextIndex).getValue();
           }
   
           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;
               userContextValue.get(userContext);
   
               if (!(
   # ifndef PEGASUS_DISABLE_PROV_USERCTXT_REQUESTOR
                     (userContext == PG_PROVMODULE_USERCTXT_REQUESTOR) ||
   # endif
   # ifndef PEGASUS_DISABLE_PROV_USERCTXT_DESIGNATED
                     (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED) ||
   # endif
   # ifndef PEGASUS_DISABLE_PROV_USERCTXT_PRIVILEGED
                     (userContext == PG_PROVMODULE_USERCTXT_PRIVILEGED) ||
   # endif
   # ifndef PEGASUS_DISABLE_PROV_USERCTXT_CIMSERVER
                     (userContext == PG_PROVMODULE_USERCTXT_CIMSERVER) ||
   # endif
                     0))
               {
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                       MessageLoaderParms(
                           "ControlProviders.ProviderRegistrationProvider."
                               "ProviderRegistrationProvider."
                               "UNSUPPORTED_USERCONTEXT_VALUE",
                           "Unsupported UserContext value: \"$0\".",
                           userContext));
               }
   
               // DesignatedUserContext property is required when UserContext == 3
               if (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)
               {
                   Uint32 designatedUserIndex = instanceObject.findProperty(
                       PEGASUS_PROPERTYNAME_MODULE_DESIGNATEDUSER);
                   if ((designatedUserIndex == PEG_NOT_FOUND) ||
                       instanceObject.getProperty(designatedUserIndex).getValue()
                           .isNull())
                   {
                       throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                           MessageLoaderParms(
                               "ControlProviders.ProviderRegistrationProvider."
                                   "ProviderRegistrationProvider."
                                   "MISSING_DESIGNATEDUSER_IN_PG_PROVIDERMODULE",
                               "Missing DesignatedUserContext property in "
                                   "PG_ProviderModule instance."));
                   }
                   else
                   {
                       // Validate that DesignatedUserContext is of String type
                       String designatedUser;
                       instanceObject.getProperty(designatedUserIndex).getValue()
                           .get(designatedUser);
                   }
               }
   #endif
           }
     }     }
     else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))     else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
Line 523 
Line 606 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");                 //"Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");
                 String missing = "ProviderModuleName";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));                  "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                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing ProviderName which is required property in PG_ProviderCapabilities class.");                 //"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_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));                  "Missing ProviderName which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing CapabilityID which is required property in PG_ProviderCapabilities class.");                 //"Missing CapabilityID which is required property in PG_ProviderCapabilities class.");
                 String missing = "CapabilityID";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSINGCAPABILITYID_IN_PG_PROVIDERCAPABILITIES",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));                  "Missing CapabilityID which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing ClassName which is required property in PG_ProviderCapabilities class.");                 //"Missing ClassName which is required property in PG_ProviderCapabilities class.");
                 String missing = "ClassName";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));                  "Missing ClassName which is required property in PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_NAMESPACES) == PEG_NOT_FOUND)          // Validate the Namespaces property
   
           Uint32 namespacesIndex =
               instanceObject.findProperty(_PROPERTY_NAMESPACES);
           Array<String> namespacesArray;
           if (namespacesIndex != PEG_NOT_FOUND)
         {         {
                 //l10n              CIMValue namespacesValue =
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  instanceObject.getProperty(namespacesIndex).getValue();
                 //"Missing Namespaces which is required property in PG_ProviderCapabilities class.");              if (!namespacesValue.isNull())
                 String missing = "Namespaces";              {
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                  namespacesValue.get(namespacesArray);
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",              }
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));  
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)          if (namespacesArray.size() == 0)
         {         {
                 //l10n  
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 //"Missing ProviderType which is required property in PG_ProviderCapabilities class.");  
                 String missing = "ProviderType";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider."
                 "Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));                      "ProviderRegistrationProvider."
                       "MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",
                   "Missing Namespaces which is required property in "
                       "PG_ProviderCapabilities class."));
           }
   
           // Validate the ProviderType property
   
           Uint32 providerTypeIndex =
               instanceObject.findProperty(_PROPERTY_PROVIDERTYPE);
           Array<Uint16> providerTypeArray;
           if (providerTypeIndex != PEG_NOT_FOUND)
           {
               CIMValue providerTypeValue =
                   instanceObject.getProperty(providerTypeIndex).getValue();
               if (!providerTypeValue.isNull())
               {
                   providerTypeValue.get(providerTypeArray);
               }
           }
   
           if (providerTypeArray.size() == 0)
           {
               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."));
           }
   
           for (Uint32 i = 0; i < providerTypeArray.size(); i++)
           {
               if ((providerTypeArray[i] < 2) ||
   #ifdef PEGASUS_DISABLE_EXECQUERY
                   (providerTypeArray[i] > 6)
   #else
                   (providerTypeArray[i] > 7)
   #endif
                                             )
               {
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                       MessageLoaderParms(
                           "ControlProviders.ProviderRegistrationProvider."
                               "ProviderRegistrationProvider.UNSUPPORTED_"
                               "PROVIDERTYPE_IN_PG_PROVIDERCAPABILITIES",
                           "Unsupported ProviderType value \"$0\" in "
                               "PG_ProviderCapabilities instance.",
                           providerTypeArray[i]));
               }
         }         }
     }     }
     else if (className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES))     else if (className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES))
Line 671 
Line 801 
         //         //
         if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing Name which is required property in PG_Provider class.");                 //"Missing Name which is required property in PG_Provider class.");
                 String missing = "Name";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",
                 "Missing $0 which is required property in $1 class.",missing,PG_Provider_Name));                  "Missing Name which is required property in PG_Provider class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                 //"Missing ProviderModuleName which is required property in PG_Provider class.");                 //"Missing ProviderModuleName which is required property in PG_Provider class.");
                 String missing = "ProviderModuleName";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",
                 "Missing $0 which is required property in $1 class.",missing,PG_Provider_Name));                  "Missing ProviderModuleName which is required property in PG_Provider class."));
         }         }
     }     }
  
Line 701 
Line 829 
         returnReference =         returnReference =
             _providerRegistrationManager->createInstance(instanceReference, instance);             _providerRegistrationManager->createInstance(instanceReference, instance);
     }     }
     catch(CIMException& e)      catch(const CIMException&)
     {     {
         throw (e);          throw;
     }     }
  
     handler.deliver(returnReference);     handler.deliver(returnReference);
Line 749 
Line 877 
  
 // l10n // l10n
     // Get the client's list of preferred languages for the response     // Get the client's list of preferred languages for the response
     AcceptLanguages al = AcceptLanguages::EMPTY;      AcceptLanguageList al;
     try     try
     {     {
         AcceptLanguageListContainer al_container =         AcceptLanguageListContainer al_container =
Line 758 
Line 886 
     }     }
     catch (...)     catch (...)
     {     {
         ;   // Leave AcceptLanguages empty          ;   // Leave AcceptLanguageList empty
     }     }
  
     CIMName className = instanceReference.getClassName();     CIMName className = instanceReference.getClassName();
Line 800 
Line 928 
         // if _PROPERTY_PROVIDERMODULENAME key not found         // if _PROPERTY_PROVIDERMODULENAME key not found
         if( !moduleFound)         if( !moduleFound)
         {         {
                 //l10n                  //l10n 485
             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,             //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                 //"key ProviderModuleName was not found");                 //"key ProviderModuleName was not found");
                 String sub = "ProviderModuleName";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.PROVIDERMODULENAME_KEY_NOT_FOUND",
                 "key $0 was not found",sub));                  "key ProviderModuleName was not found"));
         }         }
  
         //         //
Line 835 
Line 962 
              if (ret_value == -2)              if (ret_value == -2)
              {              {
 //L10N TODO //L10N TODO
                  throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                      "disable the provider failed: Provider is busy.");                       //"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&)         catch(CIMException&)
Line 866 
Line 996 
         // if _PROPERTY_PROVIDERMODULE_NAME key not found         // if _PROPERTY_PROVIDERMODULE_NAME key not found
         if( !moduleFound)         if( !moduleFound)
         {         {
                 //l10n                  //l10n 485
         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                 //"key Name was not found");                 //"key Name was not found");
                 String sub = "Name";  
                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(                 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                 "key $0 was not found",sub));                  "key Name was not found"));
         }         }
  
         //         //
Line 902 
Line 1031 
             if (ret_value == -2)             if (ret_value == -2)
             {             {
 //L10N TODO //L10N TODO
                  throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                   //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                      "disable the provider module failed: Provider is busy.");                      // "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)          catch(const CIMException&)
         {         {
             throw (e);              throw;
         }         }
     }     }
  
Line 916 
Line 1048 
     {     {
         _providerRegistrationManager->deleteInstance(instanceReference);         _providerRegistrationManager->deleteInstance(instanceReference);
     }     }
     catch(CIMException& e)      catch(const CIMException&)
     {     {
         throw (e);          throw;
     }     }
  
     // complete processing the request     // complete processing the request
Line 964 
Line 1096 
  
 // l10n // l10n
     // Get the client's list of preferred languages for the response     // Get the client's list of preferred languages for the response
     AcceptLanguages al = AcceptLanguages::EMPTY;      AcceptLanguageList al;
     try     try
     {     {
         AcceptLanguageListContainer al_container =         AcceptLanguageListContainer al_container =
Line 973 
Line 1105 
     }     }
     catch (...)     catch (...)
     {     {
         ;   // Leave AcceptLanguages empty          ;   // Leave AcceptLanguageList empty
     }     }
  
     String moduleName;     String moduleName;
Line 994 
Line 1126 
     // if _PROPERTY_PROVIDERMODULE_NAME key not found     // if _PROPERTY_PROVIDERMODULE_NAME key not found
     if( !moduleFound)     if( !moduleFound)
     {     {
         //l10n          //l10n 485
         String sub = "Name";  
         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(         throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(
                 "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",                  "ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                 "key $0 was not found",sub));                  "key Name was not found"));
     }     }
  
     handler.processing();     handler.processing();
  
     Sint16 ret_value;     Sint16 ret_value;
  
       try
       {
     if(methodName.equal(_STOP_PROVIDER))     if(methodName.equal(_STOP_PROVIDER))
     {     {
         // disable module         // disable module
         try  
         {  
 // l10n  
              ret_value =  _disableModule(objectReference, moduleName, false, al);              ret_value =  _disableModule(objectReference, moduleName, false, al);
         }         }
         catch(CIMException& e)  
         {  
              throw (e);  
         }  
   
         CIMValue retValue(ret_value);  
         handler.deliver(retValue);  
         handler.complete();  
         return;  
     }  
     else if(methodName.equal(_START_PROVIDER))     else if(methodName.equal(_START_PROVIDER))
     {     {
         //              // enable module
         // get module status               ret_value =  _enableModule(objectReference, moduleName, al);
         //  
         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)  
             {  
                 ret_value = 1;  
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }             }
           else
             // retValue equals 2 if module is stopping  
             // at this stage, module can not be started  
             if (_OperationalStatus[i] == _MODULE_STOPPING)  
             {             {
                 ret_value = 2;              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }             }
         }         }
       catch(const CIMException&)
         // get module instance  
         CIMInstance mInstance =  
             _providerRegistrationManager->getInstance(objectReference);  
   
         //  
         // get provider manager service  
         //  
         MessageQueueService * _service = _getProviderManagerService();  
   
         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++)  
             {             {
                 if (_opStatus[i] == _MODULE_OK)          throw;
                 {  
                     // module was enabled successfully  
                     ret_value = 0;  
                     CIMValue retValue(ret_value);  
                     handler.deliver(retValue);  
                     handler.complete();  
                     return;  
                 }  
             }  
         }         }
  
         // enable failed  
         ret_value = -1;  
         CIMValue retValue(ret_value);         CIMValue retValue(ret_value);
         handler.deliver(retValue);         handler.deliver(retValue);
         handler.complete();         handler.complete();
         return;  
     }  
     else  
     {  
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);  
     }  
 } }
  
 // get provider manager service // get provider manager service
Line 1130 
Line 1188 
     MessageQueueService * _service = _getProviderManagerService();     MessageQueueService * _service = _getProviderManagerService();
     Uint32 _queueId = _service->getQueueId();     Uint32 _queueId = _service->getQueueId();
  
     callback_data *cb_data = new callback_data(this);  
   
     // create request envelope     // create request envelope
     AsyncLegacyOperationStart * asyncRequest =     AsyncLegacyOperationStart * asyncRequest =
         new AsyncLegacyOperationStart (         new AsyncLegacyOperationStart (
Line 1146 
Line 1202 
                                                           asyncRequest);                                                           asyncRequest);
     CIMDisableModuleResponseMessage * response =     CIMDisableModuleResponseMessage * response =
         reinterpret_cast<CIMDisableModuleResponseMessage *>(         reinterpret_cast<CIMDisableModuleResponseMessage *>(
              (static_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;
         delete asyncRequest;         delete asyncRequest;
         delete asyncReply;         delete asyncReply;
         delete response;         delete response;
         throw (e);          throw e;
     }     }
  
     Array<Uint16> operationalStatus = response->operationalStatus;     Array<Uint16> operationalStatus = response->operationalStatus;
Line 1171 
Line 1227 
     MessageQueueService * _service = _getProviderManagerService();     MessageQueueService * _service = _getProviderManagerService();
     Uint32 _queueId = _service->getQueueId();     Uint32 _queueId = _service->getQueueId();
  
     callback_data *cb_data = new callback_data(this);  
   
     // create request envelope     // create request envelope
     AsyncLegacyOperationStart * asyncRequest =     AsyncLegacyOperationStart * asyncRequest =
         new AsyncLegacyOperationStart (         new AsyncLegacyOperationStart (
Line 1187 
Line 1241 
                                                           asyncRequest);                                                           asyncRequest);
     CIMEnableModuleResponseMessage * response =     CIMEnableModuleResponseMessage * response =
         reinterpret_cast<CIMEnableModuleResponseMessage *>(         reinterpret_cast<CIMEnableModuleResponseMessage *>(
              (static_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 1210 
Line 1264 
 void ProviderRegistrationProvider::_sendTerminationMessageToSubscription( void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(
     const CIMObjectPath & ref, const String & moduleName,     const CIMObjectPath & ref, const String & moduleName,
     const Boolean disableProviderOnly,     const Boolean disableProviderOnly,
     const AcceptLanguages & al)      const AcceptLanguageList & al)
 { {
     CIMInstance instance;     CIMInstance instance;
     String _moduleName;     String _moduleName;
Line 1245 
Line 1299 
             {             {
                 reference.setKeyBindings(keys);                 reference.setKeyBindings(keys);
                 instance = _providerRegistrationManager->getInstance(reference);                 instance = _providerRegistrationManager->getInstance(reference);
                   //
                   // if the provider is indication provider
                   //
                   if (_isIndicationProvider(moduleName, instance))
                   {
                 instances.append(instance);                 instances.append(instance);
             }             }
         }         }
     }     }
       }
     else     else
     {     {
             instance = _providerRegistrationManager->getInstance(ref);             instance = _providerRegistrationManager->getInstance(ref);
   
           //
           // if the provider is indication provider
           //
           if (_isIndicationProvider(moduleName, instance))
           {
             instances.append(instance);             instances.append(instance);
     }     }
       }
  
     //     //
     // get indication server queueId     // get indication server queueId
Line 1271 
Line 1338 
                 QueueIdStack(_service->getQueueId()));                 QueueIdStack(_service->getQueueId()));
  
 // l10n // l10n
         termination_req->acceptLanguages = al;          termination_req->operationContext.set(AcceptLanguageListContainer(al));
  
         // create request envelope         // create request envelope
         AsyncLegacyOperationStart * asyncRequest =          AsyncLegacyOperationStart asyncRequest
             new AsyncLegacyOperationStart (              (_service->get_next_xid(),
                 _service->get_next_xid(),  
                 NULL,                 NULL,
                 _queueId,                 _queueId,
                 termination_req,                 termination_req,
                 _queueId);                 _queueId);
  
         if( false  == _controller->ClientSendForget(          AutoPtr <AsyncReply> asyncReply
                            *_client_handle,              (_controller->ClientSendWait (* _client_handle, _queueId,
                            _queueId,              &asyncRequest));
                            asyncRequest))  
           AutoPtr <CIMNotifyProviderTerminationResponseMessage> response
               (reinterpret_cast <CIMNotifyProviderTerminationResponseMessage *>
               ((dynamic_cast <AsyncLegacyOperationResult *>
               (asyncReply.get ()))->get_result ()));
   
           if (response->cimException.getCode () != CIM_ERR_SUCCESS)
         {         {
             delete asyncRequest;              CIMException e = response->cimException;
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);              throw e;
         }         }
     }     }
 } }
Line 1311 
Line 1383 
     const CIMObjectPath & objectReference,     const CIMObjectPath & objectReference,
     const String & moduleName,     const String & moduleName,
     Boolean disableProviderOnly,     Boolean disableProviderOnly,
     const AcceptLanguages & al)         // l10n      const AcceptLanguageList & al)
 { {
         //         //
         // get module status         // get module status
Line 1322 
Line 1394 
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
         {         {
             // retValue equals 1 if module is already disabled             // retValue equals 1 if module is already disabled
             if (_OperationalStatus[i] == _MODULE_STOPPED ||              if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED ||
                 _OperationalStatus[i] == _MODULE_STOPPING)                  _OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING)
             {             {
                 return (1);                 return (1);
             }             }
Line 1335 
Line 1407 
         String _moduleName;         String _moduleName;
         Uint16 providers;         Uint16 providers;
         CIMObjectPath providerRef;         CIMObjectPath providerRef;
           Boolean indProvider = false;
           Array<Boolean> indicationProviders;
  
         // disable a provider module or delete a provider module         // disable a provider module or delete a provider module
         if (!disableProviderOnly)         if (!disableProviderOnly)
Line 1394 
Line 1468 
                     providerRef.setKeyBindings(keys);                     providerRef.setKeyBindings(keys);
                     instance = _providerRegistrationManager->getInstance                     instance = _providerRegistrationManager->getInstance
                         (providerRef);                         (providerRef);
                       if (_isIndicationProvider(moduleName, instance))
                       {
                           indProvider = true;
                           indicationProviders.append(true);
                       }
                       else
                       {
                           indicationProviders.append(false);
                       }
                     instances.append(instance);                     instances.append(instance);
                 }                 }
  
Line 1401 
Line 1484 
         }         }
         else         else
         {         {
             instances.append(_providerRegistrationManager->getInstance              instance = _providerRegistrationManager->getInstance(objectReference);
                  (objectReference));              if (_isIndicationProvider(moduleName, instance))
               {
                   indProvider = true;
                   indicationProviders.append(true);
               }
               else
               {
                   indicationProviders.append(false);
               }
   
               instances.append(instance);
         }         }
  
         //         //
Line 1419 
Line 1512 
                     mInstance,                     mInstance,
                     instances,                     instances,
                     disableProviderOnly,                     disableProviderOnly,
                       indicationProviders,
                     QueueIdStack(_service->getQueueId()));                     QueueIdStack(_service->getQueueId()));
 // l10n // l10n
             disable_req->acceptLanguages = al;                  disable_req->operationContext.set(AcceptLanguageListContainer(al));;
  
             Array<Uint16> _opStatus =             Array<Uint16> _opStatus =
                 _sendDisableMessageToProviderManager(disable_req);                 _sendDisableMessageToProviderManager(disable_req);
Line 1431 
Line 1525 
                 for (Uint32 i = 0; i<_opStatus.size(); i++)                 for (Uint32 i = 0; i<_opStatus.size(); i++)
                 {                 {
                     // module was disabled successfully                     // module was disabled successfully
                     if (_opStatus[i] == _MODULE_STOPPED)                      if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED)
                       {
                           if (indProvider)
                     {                     {
                         // send termination message to subscription service                         // send termination message to subscription service
                         _sendTerminationMessageToSubscription(objectReference,                         _sendTerminationMessageToSubscription(objectReference,
                                 moduleName, false, al);                                 moduleName, false, al);
                           }
                         return (0);                         return (0);
                     }                     }
  
                     // module is not disabled since there are pending                     // module is not disabled since there are pending
                     // requests for the providers in the module                     // requests for the providers in the module
                     if (_opStatus[i] == _MODULE_OK)                      if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)
                     {                     {
                         return (-2);                         return (-2);
                     }                     }
Line 1449 
Line 1546 
             }             }
             else // disable provider             else // disable provider
             {             {
                   if (indProvider)
                   {
                 _sendTerminationMessageToSubscription(objectReference,                 _sendTerminationMessageToSubscription(objectReference,
                         moduleName, true, al);                         moduleName, true, al);
                   }
                 return (0);                 return (0);
             }             }
         }         }
Line 1459 
Line 1559 
         return (-1);         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 AcceptLanguageList & 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] == CIM_MSE_OPSTATUS_VALUE_OK)
               {
                   return (1);
               }
   
               // retValue equals 2 if module is stopping
               // at this stage, module can not be started
               if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_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->operationContext.set(AcceptLanguageListContainer(al));;
   
               Array<Uint16> _opStatus;
               _opStatus = _sendEnableMessageToProviderManager(enable_req);
   
               for (Uint32 i = 0; i<_opStatus.size(); i++)
               {
                   // module is enabled successfully
                   if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)
                   {
                       enabled = true;
                   }
               }
           }
   
           if (enabled)
           {
               //
               // Since module is enabled, need get updated module instance
               //
               CIMInstance updatedModuleInstance =
                   _providerRegistrationManager->getInstance(moduleRef);
   
               // module is enabled, initialize providers as necessary
               _providerRegistrationManager->initializeProviders(
                   updatedModuleInstance);
   
               //
               // 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(updatedModuleInstance,
                                                            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 AcceptLanguageList & al)
   {
       //
       // get indication server queueId
       //
       MessageQueueService * _service = _getIndicationService();
   
       if (_service != NULL)
       {
           Uint32 _queueId = _service->getQueueId();
   
           CIMNotifyProviderEnableRequestMessage * enable_req =
                   new CIMNotifyProviderEnableRequestMessage (
                       XmlWriter::getNextMessageId (),
                       capInstances,
                       QueueIdStack(_service->getQueueId()));
   
           enable_req->operationContext.set(AcceptLanguageListContainer(al));
       enable_req->operationContext.insert(ProviderIdContainer(mInstance,pInstance));
   
           // create request envelope
           AsyncLegacyOperationStart * asyncRequest =
               new AsyncLegacyOperationStart (
                   _service->get_next_xid(),
                   NULL,
                   _queueId,
                   enable_req,
                   _queueId);
   
           AsyncReply * asyncReply =
               _controller->ClientSendWait(*_client_handle,
                                           _queueId,
                                           asyncRequest);
   
           CIMNotifyProviderEnableResponseMessage * response =
               reinterpret_cast<CIMNotifyProviderEnableResponseMessage *>(
                   (dynamic_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());
   
           if (response->cimException.getCode() != CIM_ERR_SUCCESS)
           {
               CIMException e = response->cimException;
               delete asyncRequest;
               delete asyncReply;
               delete response;
               throw e;
           }
   
           delete asyncRequest;
           delete asyncReply;
           delete response;
       }
   }
   
   // If provider is an indication provider, return true,
   // otherwise, return false
   Boolean ProviderRegistrationProvider::_isIndicationProvider(
       const String & moduleName,
       const CIMInstance & instance)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(_PROPERTY_PROVIDER_NAME);
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       return (_providerRegistrationManager->isIndicationProvider(
               moduleName, providerName));
   }
   
   //
   // 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.51  
changed lines
  Added in v.1.84
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2