(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.8 and 1.37

version 1.8, 2002/05/03 21:43:21 version 1.37, 2002/09/19 16:17:36
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // 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 26 
 // 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 37 
 #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>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 /** /**
    The name of the PG_Provider class  
 */  
 static const char _CLASS_PG_PROVIDER [] = "PG_Provider";  
   
 /**  
    The name of the provider capabilities class  
 */  
 static const char _CLASS_PROVIDER_CAPABILITIES [] = "PG_ProviderCapabilities";  
   
 /**  
    The name of the provider module class  
 */  
 static const char _CLASS_PROVIDER_MODULE [] = "PG_ProviderModule";  
   
 /**  
    The name of the operational status property    The name of the operational status property
 */ */
 static const char _PROPERTY_OPERATIONALSTATUS [] = "OperationalStatus";  static const CIMName _PROPERTY_OPERATIONALSTATUS  =
       CIMName ("OperationalStatus");
  
 /** /**
    The name of the name property for PG_Provider class    The name of the name property for PG_Provider class
 */ */
 static const char _PROPERTY_PROVIDER_NAME [] = "Name";  static const CIMName _PROPERTY_PROVIDER_NAME  = CIMName ("Name");
  
 /** /**
    The name of the Name property for PG_ProviderModule class    The name of the Name property for PG_ProviderModule class
 */ */
 static const char _PROPERTY_PROVIDERMODULE_NAME [] = "Name";  static const CIMName _PROPERTY_PROVIDERMODULE_NAME  = CIMName ("Name");
   
   /**
      The name of the Vendor property for PG_ProviderModule class
   */
   static const CIMName _PROPERTY_VENDOR  = CIMName ("Vendor");
  
 /** /**
    The name of the Version property for PG_ProviderModule class    The name of the Version property for PG_ProviderModule class
 */ */
 static const char _PROPERTY_VERSION [] = "Version";  static const CIMName _PROPERTY_VERSION  = CIMName ("Version");
  
 /** /**
    The name of the interface type property for PG_ProviderModule class    The name of the interface type property for PG_ProviderModule class
 */ */
 static const char _PROPERTY_INTERFACETYPE [] = "InterfaceType";  static const CIMName _PROPERTY_INTERFACETYPE  = CIMName ("InterfaceType");
  
 /** /**
    The name of the interface version property for PG_ProviderModule class    The name of the interface version property for PG_ProviderModule class
 */ */
 static const char _PROPERTY_INTERFACEVERSION [] = "InterfaceVersion";  static const CIMName _PROPERTY_INTERFACEVERSION  = CIMName ("InterfaceVersion");
  
 /** /**
    The name of the location property for PG_ProviderModule class    The name of the location property for PG_ProviderModule class
 */ */
 static const char _PROPERTY_LOCATION [] = "Location";  static const CIMName _PROPERTY_LOCATION  = CIMName ("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    The name of the provider module name  property for provider capabilities class
 */ */
 static const char _PROPERTY_PROVIDERMODULENAME [] = "ProviderModuleName";  static const CIMName _PROPERTY_PROVIDERMODULENAME  =
       CIMName ("ProviderModuleName");
  
 /** /**
    The name of the provider name  property for provider capabilities class    The name of the provider name  property for provider capabilities class
 */ */
 static const char _PROPERTY_PROVIDERNAME [] = "ProviderName";  static const CIMName _PROPERTY_PROVIDERNAME  = CIMName ("ProviderName");
  
 /** /**
    The name of the classname property for provider capabilities class    The name of the classname property for provider capabilities class
 */ */
 static const char _PROPERTY_CLASSNAME [] = "ClassName";  static const CIMName _PROPERTY_CLASSNAME  = CIMName ("ClassName");
  
 /** /**
    The name of the Namespace property for provider capabilities class    The name of the Namespace property for provider capabilities class
 */ */
 static const char _PROPERTY_NAMESPACES [] = "Namespaces";  static const CIMName _PROPERTY_NAMESPACES  = CIMName ("Namespaces");
  
 /** /**
    The name of the provider type  property for provider capabilities class    The name of the provider type  property for provider capabilities class
 */ */
 static const char _PROPERTY_PROVIDERTYPE [] = "ProviderType";  static const CIMName _PROPERTY_PROVIDERTYPE  = CIMName ("ProviderType");
  
 /** /**
    The name of the supported properties property for provider capabilities class    The name of the supported properties property for provider capabilities class
 */ */
 static const char _PROPERTY_SUPPORTEDPROPERTIES [] = "SupportedProperties";  static const CIMName _PROPERTY_SUPPORTEDPROPERTIES  =
       CIMName ("SupportedProperties");
  
 /** /**
    The name of the supported methods property for provider capabilities class    The name of the supported methods property for provider capabilities class
 */ */
 static const char _PROPERTY_SUPPORTEDMETHODS [] = "SupportedMethods";  static const CIMName _PROPERTY_SUPPORTEDMETHODS  = CIMName ("SupportedMethods");
  
 /** /**
    Registered instance provider type    Registered instance provider type
Line 150 
Line 148 
 /** /**
    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 _PROVIDER_OK        = 2;  static const Uint16 _MODULE_OK        = 2;
   
   static const Uint16 _MODULE_STOPPING   = 9;
  
 static const Uint16 _PROVIDER_STOPPED   = 10;  static const Uint16 _MODULE_STOPPED   = 10;
  
 ProviderRegistrationProvider::ProviderRegistrationProvider( ProviderRegistrationProvider::ProviderRegistrationProvider(
     ProviderRegistrationManager * providerRegistrationManager)     ProviderRegistrationManager * providerRegistrationManager)
Line 172 
Line 172 
  
     _controller = &(ModuleController::get_client_handle(_id, &_client_handle));     _controller = &(ModuleController::get_client_handle(_id, &_client_handle));
     if(_client_handle == NULL)     if(_client_handle == NULL)
       ThrowUnitializedHandle();          throw UninitializedObjectException();
 } }
  
 ProviderRegistrationProvider::~ProviderRegistrationProvider(void) ProviderRegistrationProvider::~ProviderRegistrationProvider(void)
Line 202 
Line 202 
 // get registered provider // get registered provider
 void ProviderRegistrationProvider::getInstance( void ProviderRegistrationProvider::getInstance(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & 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(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
 { {
           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, _CLASS_PG_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_MODULE))         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_INVALID_CLASS);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
Line 241 
Line 249 
 // get all registered providers // get all registered providers
 void ProviderRegistrationProvider::enumerateInstances( void ProviderRegistrationProvider::enumerateInstances(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & 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(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
 { {
           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, _CLASS_PG_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_MODULE))         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_INVALID_CLASS);          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 270 
Line 286 
         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 283 
Line 295 
 // get all registered provider names // get all registered provider names
 void ProviderRegistrationProvider::enumerateInstanceNames( void ProviderRegistrationProvider::enumerateInstanceNames(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & classReference,      const CIMObjectPath & classReference,
     ResponseHandler<CIMReference> & handler)      ObjectPathResponseHandler & handler)
   {
       if(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
 { {
           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, _CLASS_PG_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_MODULE))         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_INVALID_CLASS);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     Array<CIMReference> enumInstanceNames;      Array<CIMObjectPath> enumInstanceNames;
  
     // get all instance names from repository     // get all instance names from repository
     try     try
Line 322 
Line 341 
 // 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 CIMReference & 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))
 { {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
               "You must have superuser privilege to modify the registration.");
       }
   
       if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
       {
           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
                              _CLASS_PROVIDER_CAPABILITIES))          (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getClassName().getString());
     }     }
  
     //     //
Line 344 
Line 388 
     //     //
     if (propertyList.isNull())     if (propertyList.isNull())
     {     {
         throw CIMException (CIM_ERR_NOT_SUPPORTED);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               "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);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                   propertyArray[i].getString());
         }         }
     }     }
  
Line 364 
Line 410 
     try     try
     {     {
         _providerRegistrationManager->modifyInstance(instanceReference,         _providerRegistrationManager->modifyInstance(instanceReference,
             instanceObject, flags, propertyArray);              instanceObject, includeQualifiers, propertyArray);
     }     }
     catch(CIMException& e)     catch(CIMException& e)
     {     {
Line 378 
Line 424 
 // register a provider // register a provider
 void ProviderRegistrationProvider::createInstance( void ProviderRegistrationProvider::createInstance(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & instanceReference,      const CIMObjectPath & instanceReference,
     const CIMInstance & instanceObject,     const CIMInstance & instanceObject,
     ResponseHandler<CIMReference> & 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();          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
     String nameSpace = instanceReference.getNameSpace();              "You must have superuser privilege to register providers.");
       }
   
       CIMName className = instanceReference.getClassName();
       CIMNamespaceName nameSpace = instanceReference.getNameSpace();
  
     CIMReference returnReference;      CIMObjectPath returnReference;
  
     CIMInstance instance = instanceObject;     CIMInstance instance = instanceObject;
  
       if(!nameSpace.equal (PEGASUS_NAMESPACENAME_INTEROP))
       {
           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, _CLASS_PG_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_MODULE))         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_INVALID_CLASS);          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, _CLASS_PROVIDER_MODULE))      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)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Name which is required property in PG_ProviderModule class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_VERSION))          if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Vendor which is required property in PG_ProviderModule class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_INTERFACETYPE))          if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Version which is required property in PG_ProviderModule class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_INTERFACEVERSION))          if (instanceObject.findProperty(_PROPERTY_INTERFACETYPE) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing InterfaceType which is required property in PG_ProviderModule class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_LOCATION))          if (instanceObject.findProperty(_PROPERTY_INTERFACEVERSION) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing InterfaceVersion which is required property in PG_ProviderModule class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_OPERATIONALSTATUS))          if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)
           {
               throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Location which is required property in PG_ProviderModule class.");
           }
   
           if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==
               PEG_NOT_FOUND)
         {         {
             Array<Uint16> _operationalStatus;             Array<Uint16> _operationalStatus;
             _operationalStatus.append(_PROVIDER_OK);              _operationalStatus.append(_MODULE_OK);
             instance.addProperty (CIMProperty             instance.addProperty (CIMProperty
                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));
         }         }
     }     }
     else if(String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES))      else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
         //         //
         // ProviderModuleName, ProviderName, InstanceID, ClassName,         // ProviderModuleName, ProviderName, InstanceID, ClassName,
         // Namespaces, and ProviderType properties must be set         // Namespaces, and ProviderType properties must be set
         //         //
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERNAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing ProviderName which is required property in PG_ProviderCapabilities class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_CAPABILITYID))          if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing CapabilityID which is required property in PG_ProviderCapabilities class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_CLASSNAME))          if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing ClassName which is required property in PG_ProviderCapabilities class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_NAMESPACES))          if (instanceObject.findProperty(_PROPERTY_NAMESPACES) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Namespaces which is required property in PG_ProviderCapabilities class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERTYPE))          if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing ProviderType which is required property in PG_ProviderCapabilities class.");
         }         }
     }     }
     else // _CLASS_PG_PROVIDER      else // PEGASUS_CLASSNAME_PROVIDER
     {     {
         //         //
         // 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_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing Name which is required property in PG_Provider class.");
         }         }
  
         if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))          if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
         {         {
             throw CIMException (CIM_ERR_INVALID_PARAMETER);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                   "Missing ProviderModuleName which is required property in PG_Provider class.");
         }         }
     }     }
  
Line 515 
Line 613 
 // Unregister a provider // Unregister a provider
 void ProviderRegistrationProvider::deleteInstance( void ProviderRegistrationProvider::deleteInstance(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & instanceReference,      const CIMObjectPath & instanceReference,
     ResponseHandler<CIMInstance> & handler)      ResponseHandler & handler)
 { {
     String className = instanceReference.getClassName();      // 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))
       {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
               "You must have superuser privilege to unregister providers.");
       }
   
       if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
       {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               instanceReference.getNameSpace().getString());
       }
   
       CIMName className = instanceReference.getClassName();
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&      if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&         !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
        !String::equalNoCase(className, _CLASS_PROVIDER_MODULE))         !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw CIMException(CIM_ERR_INVALID_CLASS);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               className.getString());
     }     }
  
     // begin processing the request     // begin processing the request
Line 537 
Line 660 
     }     }
     catch(CIMException& e)     catch(CIMException& e)
     {     {
        cout << " caught exception in ProviderRegistrationProvider" << endl;  
        cout << " rethrowing " << endl;  
   
         throw (e);         throw (e);
     }     }
  
Line 550 
Line 670 
 // Block a provider, unblock a provider, and stop a provider // Block a provider, unblock a provider, and stop a provider
 void ProviderRegistrationProvider::invokeMethod( void ProviderRegistrationProvider::invokeMethod(
     const OperationContext & context,     const OperationContext & context,
     const CIMReference & objectReference,      const CIMObjectPath & objectReference,
     const String & methodName,      const CIMName & methodName,
     const Array<CIMParamValue> & inParameters,     const Array<CIMParamValue> & inParameters,
     Array<CIMParamValue> & outParameters,      MethodResultResponseHandler & handler)
     ResponseHandler<CIMValue> & 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))
 { {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
               "You must have superuser privilege to disable or enable providers.");
       }
   
       if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
       {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               objectReference.getNameSpace().getString());
       }
   
     String moduleName;     String moduleName;
     Boolean moduleFound = false;     Boolean moduleFound = false;
  
     // get module name from reference     // get module name from reference
     Array<KeyBinding> keys = objectReference.getKeyBindings();      Array<CIMKeyBinding> 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_PROVIDERMODULE_NAME))
         {         {
             moduleName = keys[i].getValue();             moduleName = keys[i].getValue();
             moduleFound = true;             moduleFound = true;
Line 584 
Line 727 
     Array<Uint16> _OperationalStatus =     Array<Uint16> _OperationalStatus =
         _providerRegistrationManager->getProviderModuleStatus( moduleName);         _providerRegistrationManager->getProviderModuleStatus( moduleName);
  
       // get module instance
       CIMInstance mInstance = _providerRegistrationManager->getInstance(objectReference);
   
     handler.processing();     handler.processing();
  
     Sint16 ret_value;     Sint16 ret_value;
  
     if(String::equalNoCase(methodName, _STOP_PROVIDER))      if(methodName.equal(_STOP_PROVIDER))
     {     {
         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] == _PROVIDER_STOPPED)              if (_OperationalStatus[i] == _MODULE_STOPPED ||
                   _OperationalStatus[i] == _MODULE_STOPPING)
             {             {
                 ret_value = 1;                 ret_value = 1;
                 CIMValue retValue(ret_value);                 CIMValue retValue(ret_value);
Line 603 
Line 750 
             }             }
         }         }
  
         CIMInstance mInstance;  
         CIMInstance instance;         CIMInstance instance;
         Array<CIMInstance> instances;         Array<CIMInstance> instances;
         String _moduleName;         String _moduleName;
  
         // get module instance  
         mInstance = _providerRegistrationManager->getInstance(objectReference);  
   
         // get all provider instances which have same module name as moduleName         // get all provider instances which have same module name as moduleName
         CIMReference providerRef(objectReference.getHost(),          CIMObjectPath providerRef(objectReference.getHost(),
                                  objectReference.getNameSpace(),                                  objectReference.getNameSpace(),
                                  PEGASUS_CLASSNAME_PROVIDER,                                  PEGASUS_CLASSNAME_PROVIDER,
                                  objectReference.getKeyBindings());                                  objectReference.getKeyBindings());
         Array<CIMNamedInstance> namedInstances;          Array<CIMInstance> namedInstances;
         namedInstances = _providerRegistrationManager->enumerateInstances(providerRef);         namedInstances = _providerRegistrationManager->enumerateInstances(providerRef);
         for(Uint32 i = 0, n=namedInstances.size(); i < n; i++)         for(Uint32 i = 0, n=namedInstances.size(); i < n; i++)
         {         {
             instance = namedInstances[i].getInstance();              instance = namedInstances[i];
             instance.getProperty(instance.findProperty             instance.getProperty(instance.findProperty
             (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);             (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);
             if (String::equalNoCase(_moduleName, moduleName))             if (String::equalNoCase(_moduleName, moduleName))
Line 635 
Line 778 
         //         //
         MessageQueueService * _service = _getProviderManagerService();         MessageQueueService * _service = _getProviderManagerService();
  
           if (_service != NULL)
           {
         // create CIMDisableModuleRequestMessage         // create CIMDisableModuleRequestMessage
         CIMDisableModuleRequestMessage * disable_req =         CIMDisableModuleRequestMessage * disable_req =
             new CIMDisableModuleRequestMessage(             new CIMDisableModuleRequestMessage(
Line 648 
Line 793 
  
         for (Uint32 i = 0; i<_opStatus.size(); i++)         for (Uint32 i = 0; i<_opStatus.size(); i++)
         {         {
             if (_opStatus[i] == _PROVIDER_STOPPED)                  if (_opStatus[i] == _MODULE_STOPPED)
             {             {
                 // module was disabled successfully                 // module was disabled successfully
                 ret_value = 0;                 ret_value = 0;
Line 661 
Line 806 
                 return;                 return;
             }             }
         }         }
           }
  
         // disable failed         // disable failed
         ret_value = -1;         ret_value = -1;
Line 669 
Line 815 
         handler.complete();         handler.complete();
         return;         return;
     }     }
     else if(String::equalNoCase(methodName, _START_PROVIDER))      else if(methodName.equal(_START_PROVIDER))
     {     {
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
         {         {
             // retValue equals 1 if module is already enabled             // retValue equals 1 if module is already enabled
             if (_OperationalStatus[i] == _PROVIDER_OK)              if (_OperationalStatus[i] == _MODULE_OK)
             {             {
                 ret_value = 1;                 ret_value = 1;
                 CIMValue retValue(ret_value);                 CIMValue retValue(ret_value);
Line 682 
Line 828 
                 handler.complete();                 handler.complete();
                 return;                 return;
             }             }
   
               // retValue equals 2 if module is stopping
               // at this stage, module can not be started
               if (_OperationalStatus[i] == _MODULE_STOPPING)
               {
                   ret_value = 2;
                   CIMValue retValue(ret_value);
                   handler.deliver(retValue);
                   handler.complete();
                   return;
               }
         }         }
  
         //         //
Line 689 
Line 846 
         //         //
         MessageQueueService * _service = _getProviderManagerService();         MessageQueueService * _service = _getProviderManagerService();
  
           if (_service != NULL)
           {
         // create CIMEnableModuleRequestMessage         // create CIMEnableModuleRequestMessage
         CIMEnableModuleRequestMessage * enable_req =         CIMEnableModuleRequestMessage * enable_req =
             new CIMEnableModuleRequestMessage(             new CIMEnableModuleRequestMessage(
                 XmlWriter::getNextMessageId (),                 XmlWriter::getNextMessageId (),
                 moduleName,                      mInstance,
                 QueueIdStack(_service->getQueueId()));                 QueueIdStack(_service->getQueueId()));
  
         Array<Uint16> _opStatus;         Array<Uint16> _opStatus;
Line 701 
Line 860 
  
         for (Uint32 i = 0; i<_opStatus.size(); i++)         for (Uint32 i = 0; i<_opStatus.size(); i++)
         {         {
             if (_opStatus[i] == _PROVIDER_OK)                  if (_opStatus[i] == _MODULE_OK)
             {             {
                 // module was enabled successfully                 // module was enabled successfully
                 ret_value = 0;                 ret_value = 0;
Line 711 
Line 870 
                 return;                 return;
             }             }
         }         }
           }
  
         // enable failed         // enable failed
         ret_value = -1;         ret_value = -1;
Line 721 
Line 881 
     }     }
     else     else
     {     {
         throw CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);
     }     }
 } }
  
Line 744 
Line 904 
     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 770 
Line 921 
             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);
     CIMEnableModuleResponseMessage * response =      CIMDisableModuleResponseMessage * response =
         reinterpret_cast<CIMEnableModuleResponseMessage *>(          reinterpret_cast<CIMDisableModuleResponseMessage *>(
              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)     if (response->cimException.getCode() != CIM_ERR_SUCCESS)
     {     {
Line 854 
Line 962 
             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 921 
Line 988 
  
 // send termination message to subscription service // send termination message to subscription service
 void ProviderRegistrationProvider::_sendTerminationMessageToSubscription( void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(
     const CIMReference & ref, const String & moduleName)      const CIMObjectPath & ref, const String & moduleName)
 { {
     CIMInstance instance;     CIMInstance instance;
     String _moduleName;     String _moduleName;
     Array<CIMInstance> instances;     Array<CIMInstance> instances;
  
     CIMReference reference("", PEGASUS_NAMESPACENAME_INTEROP,      CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,
         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());
  
     // get all registered providers     // get all registered providers
     Array<CIMNamedInstance> enumInstances =      Array<CIMInstance> enumInstances =
         _providerRegistrationManager->enumerateInstances(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=enumInstances.size(); i < n; i++)
     {     {
         instance = enumInstances[i].getInstance();          instance = enumInstances[i];
  
         //         //
         // get provider module name         // get provider module name
Line 955 
Line 1022 
     // 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 978 
Line 1048 
                            asyncRequest))                            asyncRequest))
     {     {
         delete asyncRequest;         delete asyncRequest;
         throw CIMException(CIM_ERR_NOT_FOUND);              throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);
           }
     }     }
 } }
  

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