providerregistrationmanager.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    Array <CIMInstance> _providerInstances;
    Array <CIMInstance> _providerModuleInstances;

    String providerName;
    String providerModuleName;

    Array<CIMName> requiredProperties;

    provider.clear();
    providerModule.clear();

    ProviderRegistrationTable* providerCapability = 0;
    ProviderRegistrationTable* _provider = 0;
    ProviderRegistrationTable* _providerModule = 0;

  try
  {
    const CIMNamespaceName & nameSpaceKey=CIMNamespaceName(WildCardNamespaceNames::check(nameSpace));
    //
    // create the key by using nameSpace, className, and providerType
    //
    String capabilityKey = _generateKey(nameSpaceKey, className, IND_PROVIDER);

    //
    // get provider capability instances from the table
    //
    if (! _registrationTable->table.lookup(capabilityKey, providerCapability))
    {
        PEG_METHOD_EXIT();

        // l10n

        // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, CAPABILITY_NOT_REGISTERED);

        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                                      MessageLoaderParms(CAPABILITY_NOT_REGISTERED_KEY,
                                                         CAPABILITY_NOT_REGISTERED));

    }

    Array<CIMInstance> instances = providerCapability->getInstances();

    for (Uint32 i=0; i < instances.size(); i++)
    {
        Array <String> _supportedProperties;
        CIMValue value;

        //
        // get supported properties
        //
        Boolean suppPropIsNull = true;
        Uint32 pos = instances[i].findProperty
            (CIMName (_PROPERTY_SUPPORTEDPROPERTIES));
        if (pos != PEG_NOT_FOUND)
        {
            value = instances[i].getProperty(pos).getValue();
            if (!value.isNull())
            {
                suppPropIsNull = false;
                value.get(_supportedProperties);
            }
        }

        //
        // get provider name
        //
        Uint32 pos2 = instances[i].findProperty
            (CIMName (_PROPERTY_PROVIDERNAME));
        if (pos2 == PEG_NOT_FOUND)
        {
            PEG_METHOD_EXIT();

            // l10n

            // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            // PROVIDER_NAME_NOT_FOUND);

            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                MessageLoaderParms(PROVIDER_NAME_NOT_FOUND_KEY,
                    PROVIDER_NAME_NOT_FOUND));
        }
        instances[i].getProperty(pos2).getValue().get(providerName);

        //
        // get provider module name
        //
        Uint32 pos3 = instances[i].findProperty
            (CIMName (_PROPERTY_PROVIDERMODULENAME));
        if (pos3 == PEG_NOT_FOUND)
        {
            PEG_METHOD_EXIT();

                // l10n

            // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            // MODULE_NAME_NOT_FOUND);

                throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                    MessageLoaderParms(MODULE_NAME_NOT_FOUND_KEY,
                        MODULE_NAME_NOT_FOUND));
        }
        instances[i].getProperty(pos3).getValue().get(providerModuleName);

        //
        // create the key by using providerModuleName and providerName
        //
        String _providerKey = _generateKey(providerModuleName, providerName);

        //
        // create the key by using providerModuleName and MODULE_KEY
        //
        String _moduleKey = _generateKey(providerModuleName, MODULE_KEY);

        if (suppPropIsNull)
        {
            //
            // provider supportes all the properties
            // get provider instance from the table
            //
            if (!_registrationTable->table.lookup(_providerKey, _provider))
            {
                PEG_METHOD_EXIT();

                // l10n

                // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, PROVIDER_NOT_FOUND);

                throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                                              MessageLoaderParms(PROVIDER_NOT_FOUND_KEY,
                                                                 PROVIDER_NOT_FOUND));
            }

            //
            // get provider module instance from the table
            //
            if (!_registrationTable->table.lookup(_moduleKey, _providerModule))
            {
                PEG_METHOD_EXIT();

                // l10n

                // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, MODULE_NOT_FOUND);

                throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                                              MessageLoaderParms(MODULE_NOT_FOUND_KEY,
                                                                 MODULE_NOT_FOUND));
            }

            _providerInstances = _provider->getInstances();

            _providerModuleInstances = _providerModule->getInstances();

            //
            // if the instance of the PG_Provider was not in the list, add the
            // instance to the list, also, add the instance of the provider module
            // to the list
            if (!containsCIMInstance (provider, _providerInstances[0]))
            {
                provider.append(_providerInstances[0]);
                providerModule.append(_providerModuleInstances[0]);
            }

        }
        else
        {
            if (!requiredPropertyList.isNull())
            {
                //
                // there is a list for the required properties
                //
                Boolean match = true;
                requiredProperties = requiredPropertyList.getPropertyNameArray();

                //
                // Compare supported properties with required properties
                //
                for (Uint32 j=0; j < requiredProperties.size() && match; j++)
                {
                    if (!Contains (_supportedProperties,
                        requiredProperties[j].getString()))
                    {
                        match = false;
                    }
                }

                //
                // Required properties are supported
                //
                if (match)
                {
                    //
                    // get provider instance from the table by using
                    // _providerKey to be key
                        //
                    if (!_registrationTable->table.lookup(_providerKey, _provider))
                    {
                        PEG_METHOD_EXIT();

                        // l10n

                        // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, PROVIDER_NOT_FOUND);

                        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                                                      MessageLoaderParms(PROVIDER_NOT_FOUND_KEY,
                                                                         PROVIDER_NOT_FOUND));
                    }

                    _providerInstances = _provider->getInstances();

                    //
                    // get provider module instance from the table
                    //
                    if (!_registrationTable->table.lookup(_moduleKey, _providerModule))
                    {
                        PEG_METHOD_EXIT();

                        // l10n

                        // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, MODULE_NOT_FOUND);

                        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                                                      MessageLoaderParms(MODULE_NOT_FOUND_KEY,
                                                                         MODULE_NOT_FOUND));

                    }

                    _providerModuleInstances = _providerModule->getInstances();

                    //
                    // if the instance of the PG_Provider was not in the list, add
                    // the instance to the list; also, add the instance of the
                    // provider module to the list
                    //
                    if (!containsCIMInstance (provider, _providerInstances[0]))
                    {
                        provider.append(_providerInstances[0]);
                        providerModule.append(_providerModuleInstances[0]);
                    }
                }
            }
        }

    }
  }
  catch (const CIMException &)
  {
    PEG_METHOD_EXIT();
    return (false);
  }

    PEG_METHOD_EXIT();
    return (true);
}

Boolean ProviderRegistrationManager::lookupIndicationConsumer(
    const String & destinationPath,
    CIMInstance & provider,
    CIMInstance & providerModule)
{
    String providerName;
    String providerModuleName;

    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
        "ProviderRegistrationManager::lookupIndicationConsumer");

    ReadLock lock(_registrationTableLock);

    ProviderRegistrationTable* consumerCapability = 0;
    ProviderRegistrationTable* _provider= 0;
    ProviderRegistrationTable* _providerModule = 0;

    //
    // create the key by using destinationPath and providerType
    //
    String consumerKey = _generateKey(destinationPath, CON_PROVIDER);
    PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "\ndestinationPath = " + destinationPath +
                     "; consumerKey = " + consumerKey);

    try
    {
        //
        // get consumer capability instance from the table
        //
        if (!_registrationTable->table.lookup(
                  consumerKey, consumerCapability))
        {
            //L10N TODO DONE
            PEG_METHOD_EXIT();
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, CONSUMER_NOT_REGISTERED);
            MessageLoaderParms parms(CONSUMER_NOT_REGISTERED_KEY, CONSUMER_NOT_REGISTERED);
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,parms);
        }

        Array<CIMInstance> instances = consumerCapability->getInstances();

        Uint32 pos = instances[0].findProperty(CIMName(_PROPERTY_PROVIDERNAME));

        if (pos == PEG_NOT_FOUND)
        {
            //L10N TODO DONE
            PEG_METHOD_EXIT();
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            //"Missing ProviderName which is key in PG_ConsumerCapabilities class.");

            MessageLoaderParms parms("Server.ProviderRegistrationManager.ProviderRegistrationManager.MISSING_PROVIDERNAME_KEY_IN_CONSUMER_CAPABILITIES",
                                     "Missing ProviderName which is key in PG_ConsumerCapabilities class.");
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,parms);
        }

        //
        // get provider name
        //
        instances[0].getProperty(pos).getValue().get(providerName);

        //
        // get provider module name
        //
        Uint32 pos2 = instances[0].findProperty
            (CIMName (_PROPERTY_PROVIDERMODULENAME));
        if (pos2 == PEG_NOT_FOUND)
        {
            //L10N TODO DONE
            PEG_METHOD_EXIT();
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            //"Missing ProviderModuleName which is key in PG_ConsumerCapabilities class.");
            MessageLoaderParms parms("Server.ProviderRegistrationManager.ProviderRegistrationManager.MISSING_PROVIDERMODULENAME_KEY_IN_CONSUMER_CAPABILITIES",
                                     "Missing ProviderModuleName which is key in PG_ConsumerCapabilities class.");
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,parms);
        }

        instances[0].getProperty(pos2).getValue().get(providerModuleName);

        //
        // create the key by using providerModuleName and providerName
        //
        String _providerKey = _generateKey(providerModuleName, providerName);

        //
        // create the key by using providerModuleName and MODULE_KEY
        //
        String _moduleKey = _generateKey(providerModuleName, MODULE_KEY);

        //
        // get provider instance from the table
        //
        if (!_registrationTable->table.lookup(_providerKey, _provider))
        {
            //L10N TODO DONE
            PEG_METHOD_EXIT();
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, PROVIDER_NOT_FOUND);
            MessageLoaderParms parms(PROVIDER_NOT_FOUND_KEY, PROVIDER_NOT_FOUND);
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
        }

        Array<CIMInstance> providerInstances = _provider->getInstances();
        provider = providerInstances[0];

        //
        // get provider module instance from the table
        //
        if (!_registrationTable->table.lookup(_moduleKey, _providerModule))
        {
            //L10N_ TODO DONE
            PEG_METHOD_EXIT();
            //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, MODULE_NOT_FOUND);
            MessageLoaderParms parms(MODULE_NOT_FOUND_KEY, MODULE_NOT_FOUND);
            throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
        }

        Array<CIMInstance> providerModuleInstances = _providerModule->getInstances();
        providerModule = providerModuleInstances[0];

    }
    catch(CIMException & exception)
    {
        Tracer::traceCIMException(TRC_PROVIDERMANAGER, Tracer::LEVEL4, exception);
        PEG_METHOD_EXIT();
        return (false);
    }

    PEG_METHOD_EXIT();
    return (true);
}

// check entries of registration table, if an entry is found with same
// moduleName, same providerName, and provider type includes indication,
// return true; otherwise, return false
Boolean ProviderRegistrationManager::isIndicationProvider(
    const String & moduleName,
    const String & providerName)
{
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
        "ProviderRegistrationManager::isIndicationProvider");