providerregistrationmanager.cpp

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

    PEG_METHOD_EXIT();
}

Boolean ProviderRegistrationManager::lookupInstanceProvider(
    const CIMNamespaceName & nameSpace,
    const CIMName & className,
    CIMInstance & provider,
    CIMInstance & providerModule,
    Boolean is_assoc,
    Boolean* has_no_query)
{
    String providerName;
    String providerModuleName;

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

    ReadLock lock(_registrationTableLock);

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

    //
    // create the key by using nameSpace, className, and providerType
    //

    const CIMNamespaceName & nameSpaceKey=CIMNamespaceName(WildCardNamespaceNames::check(nameSpace));

    String capabilityKey;
    if (!is_assoc) {
       if (has_no_query) {
          *has_no_query=true;
          capabilityKey = _generateKey(nameSpaceKey, className, INSTANCE_QUERY_PROVIDER);
          if (!_registrationTable->table.lookup(
                  capabilityKey, providerCapability))
             capabilityKey = _generateKey(nameSpaceKey, className, INS_PROVIDER);
          else *has_no_query=false;
       }
    else
          capabilityKey = _generateKey(nameSpaceKey, className, INS_PROVIDER);
    }
    else {
        capabilityKey = _generateKey(nameSpaceKey, className, ASSO_PROVIDER);
    }
    PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                     "\nnameSpace = " + nameSpace.getString() +
                     "; className = " + className.getString() +
                     "; capabilityKey = " + capabilityKey);

    try
    {
        //
        // get provider capability instance from the table
        //
        if (providerCapability==0 && !_registrationTable->table.lookup(
                  capabilityKey, providerCapability))
        {
            Tracer::trace(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                CAPABILITY_NOT_REGISTERED);
            PEG_METHOD_EXIT();
            return false;
        }

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

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

        if (pos == PEG_NOT_FOUND)
        {
            Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                PROVIDER_NAME_NOT_FOUND);
            PEG_METHOD_EXIT();
            return false;
        }

        //
        // 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)
        {
            Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                MODULE_NAME_NOT_FOUND);
            PEG_METHOD_EXIT();
            return false;
        }

        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))
        {
            Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
              PROVIDER_NOT_FOUND);
            PEG_METHOD_EXIT();
            return false;
        }

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

        //
        // get provider module instance from the table
        //
        if (!_registrationTable->table.lookup(_moduleKey, _providerModule))
        {
            Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                MODULE_NOT_FOUND);
            PEG_METHOD_EXIT();
            return false;
        }

        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);
}

Boolean ProviderRegistrationManager::lookupMethodProvider(
    const CIMNamespaceName & nameSpace,
    const CIMName & className,
    const CIMName & method,
    CIMInstance & provider,
    CIMInstance & providerModule)
{
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
        "ProviderRegistrationManager::lookupMethodProvider");

    ReadLock lock(_registrationTableLock);

    String providerName;
    String providerModuleName;
    Array<CIMInstance> instances;

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

  try
  {
    const CIMNamespaceName & nameSpaceKey=CIMNamespaceName(WildCardNamespaceNames::check(nameSpace));
    //
    // check if the provider was registered to support all methods
    // create the key by using nameSpace, className, allMethods, and providerType
    //
    String capabilityKey = _generateKey(nameSpaceKey, className, "{}", MET_PROVIDER);

    if (_registrationTable->table.lookup(capabilityKey, providerCapability))
    {
        // provider was registered to support all the methods

        instances = providerCapability->getInstances();

         //
        // get provider name
        //
        Uint32 pos = instances[0].findProperty(CIMName(_PROPERTY_PROVIDERNAME));
            if (pos == 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[0].getProperty(pos).getValue().get(providerName);

        //
        // get provider module name
        //
        Uint32 pos2 = instances[0].findProperty
            (CIMName (_PROPERTY_PROVIDERMODULENAME));
        if (pos2 == 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[0].getProperty(pos2).getValue().get(providerModuleName);
    }
    else
    {
        //
        // provider was not registered to support all the methods
        // create the key by using nameSpace, className, method, and providerType
        //
        capabilityKey = _generateKey(nameSpaceKey, className, method.getString(),
            MET_PROVIDER);
        if (_registrationTable->table.lookup(capabilityKey, providerCapability))
        {
            //
            // provider was registerted to support the method
            //
            instances = providerCapability->getInstances();

            //
            // get provider name
            //
            Uint32 pos = instances[0].findProperty
                (CIMName (_PROPERTY_PROVIDERNAME));
            if (pos == 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[0].getProperty(pos).getValue().get(providerName);

            //
            // get provider module name
            //
            Uint32 pos2 = instances[0].findProperty
                (CIMName (_PROPERTY_PROVIDERMODULENAME));
            if (pos2 == 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[0].getProperty(pos2).getValue().get(providerModuleName);
        }
        else
        {
            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));

        }

    }

    //
    // 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))
    {
        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));
    }

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

    //
    // 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));
    }

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

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

    PEG_METHOD_EXIT();
    return (true);
}

// Lookup the association providers associated with a Class. Note that this
// function returns an array but that should never happen until we reach
// the point where we are registering multiple providers for the same
// class
Boolean ProviderRegistrationManager::lookupAssociationProvider(
    const CIMNamespaceName & nameSpace,
    const CIMName & assocClassName,
    Array<CIMInstance>& providers,
    Array<CIMInstance>& providerModules)
{
    CIMInstance pInstance;
    CIMInstance pmInstance;
    String providerName;

    if (lookupInstanceProvider(
        nameSpace, assocClassName, pInstance, pmInstance, true))
    {
        // get the provider name
        Uint32 pos = pInstance.findProperty(CIMName ("Name"));

        if ( pos != PEG_NOT_FOUND )
        {
            pInstance.getProperty(pos).getValue().get(providerName);

            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                         "providerName = " + providerName + " found.");
            providers.append(pInstance);
            providerModules.append(pmInstance);
        }
    }

    return (providers.size() > 0);
}

Boolean ProviderRegistrationManager::getIndicationProviders(
    const CIMNamespaceName & nameSpace,
    const CIMName & className,
    const CIMPropertyList & requiredPropertyList,
    Array<CIMInstance> & provider,
    Array<CIMInstance> & providerModule)
{
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
        "ProviderRegistrationManager::getIndicationProviders");

    ReadLock lock(_registrationTableLock);