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

version 1.54, 2003/09/12 18:30:50 version 1.58, 2003/11/04 19:00:59
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 991 
Line 993 
  
     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(CIMException& e)
         // 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)  
                 {                 {
                     // module was enabled successfully          throw (e);
                     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;         return;
     }     }
     else  
     {  
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);  
     }  
 }  
  
 // get provider manager service // get provider manager service
 MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService() MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()
Line 1231 
Line 1161 
             {             {
                 reference.setKeyBindings(keys);                 reference.setKeyBindings(keys);
                 instance = _providerRegistrationManager->getInstance(reference);                 instance = _providerRegistrationManager->getInstance(reference);
                   //
                   // if the provider is indication provider
                   //
                   if (_isIndicationProvider(moduleName, instance, reference))
                   {
                 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, ref))
           {
             instances.append(instance);             instances.append(instance);
     }     }
       }
  
     //     //
     // get indication server queueId     // get indication server queueId
Line 1321 
Line 1264 
         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 1380 
Line 1325 
                     providerRef.setKeyBindings(keys);                     providerRef.setKeyBindings(keys);
                     instance = _providerRegistrationManager->getInstance                     instance = _providerRegistrationManager->getInstance
                         (providerRef);                         (providerRef);
                       if (_isIndicationProvider(moduleName, instance, providerRef))
                       {
                           indProvider = true;
                           indicationProviders.append(true);
                       }
                       else
                       {
                           indicationProviders.append(false);
                       }
                     instances.append(instance);                     instances.append(instance);
                 }                 }
  
Line 1387 
Line 1341 
         }         }
         else         else
         {         {
             instances.append(_providerRegistrationManager->getInstance              instance = _providerRegistrationManager->getInstance(objectReference);
                  (objectReference));              if (_isIndicationProvider(moduleName, instance, objectReference))
               {
                   indProvider = true;
                   indicationProviders.append(true);
               }
               else
               {
                   indicationProviders.append(false);
               }
   
               instances.append(instance);
         }         }
  
         //         //
Line 1405 
Line 1369 
                     mInstance,                     mInstance,
                     instances,                     instances,
                     disableProviderOnly,                     disableProviderOnly,
                       indicationProviders,
                     QueueIdStack(_service->getQueueId()));                     QueueIdStack(_service->getQueueId()));
 // l10n // l10n
             disable_req->acceptLanguages = al;             disable_req->acceptLanguages = al;
Line 1419 
Line 1384 
                     // module was disabled successfully                     // module was disabled successfully
                     if (_opStatus[i] == _MODULE_STOPPED)                     if (_opStatus[i] == _MODULE_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);
                     }                     }
  
Line 1435 
Line 1403 
             }             }
             else // disable provider             else // disable provider
             {             {
                   if (indProvider)
                   {
                 _sendTerminationMessageToSubscription(objectReference,                 _sendTerminationMessageToSubscription(objectReference,
                         moduleName, true, al);                         moduleName, true, al);
                   }
                 return (0);                 return (0);
             }             }
         }         }
Line 1445 
Line 1416 
         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 AcceptLanguages & al)
   {
           //
           // get module status
           //
           Array<Uint16> _OperationalStatus =
               _providerRegistrationManager->getProviderModuleStatus( moduleName);
   
           for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
           {
               // retValue equals 1 if module is already enabled
               if (_OperationalStatus[i] == _MODULE_OK)
               {
                   return (1);
               }
   
               // retValue equals 2 if module is stopping
               // at this stage, module can not be started
               if (_OperationalStatus[i] == _MODULE_STOPPING)
               {
                   return (2);
               }
           }
   
           // get module instance
           CIMInstance mInstance =
               _providerRegistrationManager->getInstance(moduleRef);
   
           //
           // get provider manager service
           //
           MessageQueueService * _service = _getProviderManagerService();
           Boolean enabled = false;
   
           if (_service != NULL)
           {
               // create CIMEnableModuleRequestMessage
               CIMEnableModuleRequestMessage * enable_req =
                   new CIMEnableModuleRequestMessage(
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       QueueIdStack(_service->getQueueId()));
   // l10n
               enable_req->acceptLanguages = al;
   
               Array<Uint16> _opStatus;
               _opStatus = _sendEnableMessageToProviderManager(enable_req);
   
               for (Uint32 i = 0; i<_opStatus.size(); i++)
               {
                   // module is enabled successfully
                   if (_opStatus[i] == _MODULE_OK)
                   {
                       enabled = true;
                   }
               }
           }
   
           if (enabled)
           {
               //
               // if the module is enabled, need to send enable message to
               // subscription service if the provider is an indication provider
               //
   
               CIMObjectPath providerRef = CIMObjectPath(String::EMPTY,
                                       moduleRef.getNameSpace(),
                                       PEGASUS_CLASSNAME_PROVIDER,
                                       Array<CIMKeyBinding>());
   
               //
               // get all provider instances which have same module name as
               // moduleName
               //
               Array<CIMObjectPath> instanceNames =
                   _providerRegistrationManager->enumerateInstanceNames(providerRef);
               CIMInstance pInstance;
               String _moduleName;
               String _providerName;
               Array<CIMInstance> capInstances;
   
               for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
               {
   
                   Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
                   for(Uint32 j=0; j < keys.size(); j++)
                   {
                       //
                       // get provider module name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                       {
                           _moduleName = keys[j].getValue();
                       }
   
                       //
                       // get provider name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDER_NAME))
                       {
                           _providerName = keys[j].getValue();
                       }
                   }
   
                   if (String::equalNoCase(_moduleName, moduleName))
                   {
                       providerRef.setKeyBindings(keys);
                       pInstance = _providerRegistrationManager->getInstance
                           (providerRef);
                       //
                       // get all the indication capability instances which belongs
                       // to this provider
                       //
                       capInstances = _getIndicationCapInstances(
                                      moduleName, pInstance, providerRef);
   
                       //
                       // if there are indication capability instances
                       //
                       if (capInstances.size() != 0)
                       {
                           _sendEnableMessageToSubscription(mInstance,
                                                            pInstance,
                                                            capInstances,
                                                            al);
                       }
                   }
               }
               return (0);
           }
   
   
           // enable failed
           return (-1);
   }
   
   // send enable message to indication service
   void ProviderRegistrationProvider::_sendEnableMessageToSubscription(
       const CIMInstance & mInstance,
       const CIMInstance & pInstance,
       const Array<CIMInstance> & capInstances,
       const AcceptLanguages & al)
   {
       //
       // get indication server queueId
       //
       MessageQueueService * _service = _getIndicationService();
   
       if (_service != NULL)
       {
           Uint32 _queueId = _service->getQueueId();
   
           CIMNotifyProviderEnableRequestMessage * enable_req =
                   new CIMNotifyProviderEnableRequestMessage (
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       pInstance,
                       capInstances,
                       QueueIdStack(_service->getQueueId()));
   
           enable_req->acceptLanguages = al;
   
           // create request envelope
           AsyncLegacyOperationStart * asyncRequest =
               new AsyncLegacyOperationStart (
                   _service->get_next_xid(),
                   NULL,
                   _queueId,
                   enable_req,
                   _queueId);
   
           if( false  == _controller->ClientSendForget(
                         *_client_handle,
                         _queueId,
                         asyncRequest))
           {
               delete asyncRequest;
               throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);
           }
   
       }
   }
   
   // If the provider is indication provider, return true,
   // otherwise, return false
   Boolean ProviderRegistrationProvider::_isIndicationProvider(
       const String & moduleName,
       const CIMInstance & instance,
       const CIMObjectPath & providerRef)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       CIMObjectPath capabilityRef;
   
       capabilityRef = CIMObjectPath(providerRef.getHost(),
                                     providerRef.getNameSpace(),
                                     PEGASUS_CLASSNAME_CAPABILITIESREGISTRATION,
                                     providerRef.getKeyBindings());
   
       // get all Capabilities instances
       Array<CIMObjectPath> instanceNames =
           _providerRegistrationManager->enumerateInstanceNames(capabilityRef);
   
       //
       // get provider module name and provider name from capability reference
       //
       String _moduleName, _providerName;
       CIMInstance capInstance;
       Array<Uint16> providerTypes;
       for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
       {
           Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
           for(Uint32 j=0; j < keys.size(); j++)
           {
                if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                {
                     _moduleName = keys[j].getValue();
                }
   
                if(keys[j].getName().equal (_PROPERTY_PROVIDERNAME))
                {
                     _providerName = keys[j].getValue();
                }
   
                //
                // if capability instance has same module name as moduleName
                // and same provider name as providerName, get provider type
                //
                if(String::equal(_moduleName, moduleName) &&
                   String::equal(_providerName, providerName))
                {
                     capInstance = _providerRegistrationManager->getInstance
                                   (instanceNames[i]);
   
                     Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));
                     if (pos != PEG_NOT_FOUND)
                     {
                          capInstance.getProperty(pos).getValue().get(providerTypes);
   
                           for (Uint32 k=0; k < providerTypes.size(); k++)
                           {
                               if (providerTypes[k] == _INDICATION_PROVIDER)
                               {
                                   return (true);
                               }
                           }
                     }
                }
           }
       }
   
       return (false);
   }
   
   //
   // get all the capability instances whose provider type is indication
   //
   Array<CIMInstance> ProviderRegistrationProvider::_getIndicationCapInstances(
       const String & moduleName,
       const CIMInstance & instance,
       const CIMObjectPath & providerRef)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       CIMObjectPath capabilityRef;
   
       capabilityRef = CIMObjectPath(providerRef.getHost(),
                                     providerRef.getNameSpace(),
                                     PEGASUS_CLASSNAME_CAPABILITIESREGISTRATION,
                                     providerRef.getKeyBindings());
   
       // get all Capabilities instances
       Array<CIMObjectPath> instanceNames =
           _providerRegistrationManager->enumerateInstanceNames(capabilityRef);
   
       String _moduleName, _providerName;
       CIMInstance capInstance;
       Array<Uint16> providerTypes;
       Array<CIMInstance> indCapInstances = 0;
       for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
       {
           Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
           for(Uint32 j=0; j < keys.size(); j++)
           {
                if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                {
                     _moduleName = keys[j].getValue();
                }
   
                if(keys[j].getName().equal (_PROPERTY_PROVIDERNAME))
                {
                     _providerName = keys[j].getValue();
                }
           }
   
          //
          // if capability instance has same module name as moduleName
          // and same provider name as providerName, get provider type
          //
          if(String::equal(_moduleName, moduleName) &&
             String::equal(_providerName, providerName))
          {
               capInstance = _providerRegistrationManager->getInstance
                                   (instanceNames[i]);
   
               Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));
               if (pos != PEG_NOT_FOUND)
               {
                   capInstance.getProperty(pos).getValue().get(providerTypes);
   
                   for (Uint32 k=0; k < providerTypes.size(); k++)
                   {
                       //
                       // if provider type of the instance is indication,
                       // append the instance
                       //
                       if (providerTypes[k] == _INDICATION_PROVIDER)
                       {
                           indCapInstances.append(capInstance);
                       }
                   }
               }
           }
       }
   
       return (indCapInstances);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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