cmpilocalprovidermanager.cpp

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

  {
    // Unexpected exception; do not assume that no providers are loaded
    PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                      "Unexpected Exception in hasActiveProviders.");
    PEG_METHOD_EXIT ();
    return true;
  }

  // No active providers were found in the _providers table
  PEG_METHOD_EXIT ();
  return false;
}

void
CMPILocalProviderManager::unloadIdleProviders (void)
{
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
        "ProviderManager::unloadIdleProviders");

    try
    {
        _provider_ctrl (UNLOAD_IDLE_PROVIDERS, this, (void *) 0);
    }
    catch (...)
    {
        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
            "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");
    }

    PEG_METHOD_EXIT ();
}

Array <
  CMPIProvider * >CMPILocalProviderManager::getIndicationProvidersToEnable ()
{
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
                    "CMPILocalProviderManager::getIndicationProvidersToEnable");

  Array < CMPIProvider * >enableProviders;

  Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                 "Number of providers in _providers table = %d",
                 _providers.size ());

  try
  {
    AutoMutex
    lock (_providerTableMutex);

    //
    // Iterate through the _providers table
    //
    for (ProviderTable::Iterator i = _providers.start (); i != 0; i++)
      {
        //
        //  Enable any indication provider with current subscriptions
        //
        CMPIProvider *
          provider = i.value ();
        if (provider->testSubscriptions ())
          {
            enableProviders.append (provider);
          }
      }

  }
  catch (const CIMException & e)
  {
    PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
                      "CIMException: " + e.getMessage ());
  }
  catch (const Exception & e)
  {
    PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
                      "Exception: " + e.getMessage ());
  }
  catch (...)
  {
    PEG_TRACE_STRING (TRC_DISCARDED_DATA, Tracer::LEVEL2,
                      "Unexpected error in getIndicationProvidersToEnable");
  }

  Tracer::trace (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                 "Number of indication providers to enable = %d",
                 enableProviders.size ());

  PEG_METHOD_EXIT ();
  return enableProviders;
}

CMPIProvider *
CMPILocalProviderManager::_initProvider (CMPIProvider * provider,
                                         const String & moduleFileName)
{
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, "_initProvider");

  CMPIProviderModule *module = 0;
  ProviderVector base;

  {
    // lock the providerTable mutex
    AutoMutex lock (_providerTableMutex);

    // lookup provider module
    module = _lookupModule (moduleFileName);
  }                             // unlock the providerTable mutex

  Boolean moduleLoaded = false;
  Boolean deleteProvider = false;
  String exceptionMsg = moduleFileName;
  {
    // lock the provider status mutex
    AutoMutex lock (provider->_statusMutex);

    if (provider->_status == CMPIProvider::INITIALIZED)
      {
        // Initialization is already complete
        return provider;
      }

    PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                      "Loading/Linking Provider Module " + moduleFileName);

    // load the provider
    try
    {
      base = module->load (provider->_name);
      moduleLoaded = true;
    }
    catch (const Exception &e)
    {
	  exceptionMsg = e.getMessage();
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Exception caught Loading/Linking Provider Module " +
                        moduleFileName+ " error is: "+exceptionMsg);
	  deleteProvider =true;
    }
    catch (...)
    {
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Unknown exception caught Loading/Linking Provider Module " +
                        moduleFileName);
       exceptionMsg = moduleFileName;
      deleteProvider = true;
    }

    if (!deleteProvider)
    {
      // initialize the provider
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
                      "Initializing Provider " + provider->getName());

      CIMOMHandle *cimomHandle = new CIMOMHandle ();
      provider->set (module, base, cimomHandle);
      provider->_quantum = 0;

      try
      {
      	provider->initialize (*(provider->_cimom_handle));
      }
      catch (const Exception &e)
      {
     	PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
				"Problem initializing: " + e.getMessage());
      	deleteProvider = true;
	exceptionMsg = e.getMessage();
      }
      catch (...) 
      {
     	PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
				"Unknown problem initializing " + provider->getName());
      	deleteProvider = true;
	exceptionMsg = provider->getName();
      }
    }                             // unlock the provider status mutex
  }
  /* We wait until this moment to delete the provider b/c we need
     be outside the scope for the AutoMutex for the provider. */
  if (deleteProvider)
  {
      // delete the cimom handle
      delete provider->_cimom_handle;
      // set provider status to UNINITIALIZED
      provider->reset ();

      // unload provider module
      if (moduleLoaded)
      {
          module->unloadModule();
      }

      AutoMutex lock (_providerTableMutex);
      _providers.remove (provider->_name);
      delete provider;

      PEG_METHOD_EXIT ();
      throw Exception(exceptionMsg);
    }

  PEG_METHOD_EXIT ();
  return (provider);
}


void
CMPILocalProviderManager::_unloadProvider (CMPIProvider * provider)
{
  //
  // NOTE:  It is the caller's responsibility to make sure that
  // the ProviderTable mutex is locked before calling this method.
  //
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, "_unloadProvider");

  PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                    "Unloading Provider " + provider->getName());

  if (provider->_current_operations.get ())
    {
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Provider cannot be unloaded due to pending operations: "
                        + provider->getName());
    }
  else
    {
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Terminating Provider " + provider->getName());


      // lock the provider mutex
      AutoMutex pr_lock (provider->_statusMutex);

      try
      {
        provider->terminate ();
      }
      catch (...)
      {
        PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL3,
                          "Error occured terminating CMPI provider " +
                          provider->getName());
      }

      // delete the cimom handle
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Destroying CMPIProvider's CIMOM Handle " +
                        provider->getName());

      delete provider->_cimom_handle;
      PEGASUS_ASSERT (provider->_module != 0);

      // unload provider module
      provider->_module->unloadModule ();
      Logger::put (Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
                   "CMPILocalProviderManager::_provider_crtl -  Unload provider $0",
                   provider->getName ());

      // set provider status to UNINITIALIZED
      provider->reset ();

      // Do not delete the provider. The function calling this function
      // takes care of that.
    }

  PEG_METHOD_EXIT ();
}

CMPIProvider *
CMPILocalProviderManager::_lookupProvider (const String & providerName)
{
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, "_lookupProvider");
  // lock the providerTable mutex
  AutoMutex lock (_providerTableMutex);
  // look up provider in cache
  CMPIProvider *pr = 0;
  if (true == _providers.lookup (providerName, pr))
    {
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Found Provider " + providerName +
                        " in CMPI Provider Manager Cache");
    }
  else
    {
      // create provider
      pr = new CMPIProvider (providerName, 0, 0);
      // insert provider in provider table
      _providers.insert (providerName, pr);

      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Created provider " + pr->getName ());
    }

  PEG_METHOD_EXIT ();
  return (pr);
}


CMPIProviderModule *
CMPILocalProviderManager::_lookupModule (const String & moduleFileName)
{
  PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, "_lookupModule");

  // look up provider module in cache
  CMPIProviderModule *module = 0;

  if (true == _modules.lookup (moduleFileName, module))
    {
      // found provider module in cache
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Found Provider Module" + moduleFileName +
                        " in Provider Manager Cache");

    }
  else
    {
      // provider module not found in cache, create provider module
      PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL4,
                        "Creating CMPI Provider Module " + moduleFileName);

      module = new CMPIProviderModule (moduleFileName);

      // insert provider module in module table
      _modules.insert (moduleFileName, module);
    }

  PEG_METHOD_EXIT ();
  return (module);
}

PEGASUS_NAMESPACE_END