PluginStartupRegistration Class Reference

#include <PluginStartupRegistration.h>

Inheritance diagram for PluginStartupRegistration:

Collaboration diagram for PluginStartupRegistration:

Public Member Functions
	PluginStartupRegistration (const std::map< wxString, std::vector< wxString > > &pluginsToProcess)
void	Run (std::chrono::seconds timeout=std::chrono::seconds(30))
const std::vector< wxString > &	GetFailedPluginsPaths () const noexcept
	Returns list of paths of plugins that didn't pass validation for some reason. More...
void	OnInternalError (const wxString &error) override
	Called on error, further processing is not possible. More...
void	OnPluginFound (const PluginDescriptor &desc) override
	Called for each plugin instance found inside module. More...
void	OnPluginValidationFailed (const wxString &providerId, const wxString &path) override
void	OnValidationFinished () override
	Called when module processing finished. More...
Public Member Functions inherited from AsyncPluginValidator::Delegate
virtual	~Delegate ()
virtual void	OnPluginFound (const PluginDescriptor &plugin)=0
	Called for each plugin instance found inside module. More...
virtual void	OnPluginValidationFailed (const wxString &providerId, const wxString &path)=0
virtual void	OnValidationFinished ()=0
	Called when module processing finished. More...
virtual void	OnInternalError (const wxString &msg)=0
	Called on error, further processing is not possible. More...

Private Member Functions
void	Stop ()
void	Skip ()
void	StopWithError (const wxString &msg)
void	ProcessNext ()

Private Attributes
std::unique_ptr< AsyncPluginValidator >	mValidator
std::vector< std::pair< wxString, std::vector< wxString > > >	mPluginsToProcess
size_t	mCurrentPluginIndex {0}
size_t	mCurrentPluginProviderIndex {0}
bool	mValidProviderFound {false}
std::vector< wxString >	mFailedPluginsPaths
std::vector< PluginDescriptor >	mFailedPluginsCache
wxWeakRef< wxDialogWrapper >	mScanDialog
wxWeakRef< wxTimer >	mTimeoutTimer
std::chrono::system_clock::duration	mTimeout {}
std::chrono::system_clock::time_point	mRequestStartTime {}

Detailed Description

Helper class that passes plugins provided in constructor to plugin validator, then "good" plugins are registered in PluginManager.

Definition at line 25 of file PluginStartupRegistration.h.

Constructor & Destructor Documentation

PluginStartupRegistration()

PluginStartupRegistration::PluginStartupRegistration

(

const std::map< wxString, std::vector< wxString > > &

pluginsToProcess

)

Definition at line 130 of file PluginStartupRegistration.cpp.

{
   for(auto& p : pluginsToProcess)
      mPluginsToProcess.push_back(p);
}

References mPluginsToProcess.

Member Function Documentation

GetFailedPluginsPaths()

const std::vector< wxString > & PluginStartupRegistration::GetFailedPluginsPaths ( ) const

noexcept

Returns list of paths of plugins that didn't pass validation for some reason.

Definition at line 205 of file PluginStartupRegistration.cpp.

{
   return mFailedPluginsPaths;
}

References mFailedPluginsPaths.

OnInternalError()

void PluginStartupRegistration::OnInternalError ( const wxString &  msg )

overridevirtual

Called on error, further processing is not possible.

Implements AsyncPluginValidator::Delegate.

Definition at line 136 of file PluginStartupRegistration.cpp.

{
   StopWithError(error);
}

References StopWithError().

Here is the call graph for this function:

OnPluginFound()

void PluginStartupRegistration::OnPluginFound ( const PluginDescriptor &  plugin )

overridevirtual

Called for each plugin instance found inside module.

Implements AsyncPluginValidator::Delegate.

Definition at line 141 of file PluginStartupRegistration.cpp.

{
   if(!mValidProviderFound)
      mFailedPluginsCache.clear();
 
   mValidProviderFound = true;
   if(!desc.IsValid())
      mFailedPluginsCache.push_back(desc);
   PluginManager::Get().RegisterPlugin(PluginDescriptor { desc });
}

References anonymous_namespace{ExportPCM.cpp}::desc, PluginManager::Get(), mFailedPluginsCache, mValidProviderFound, and PluginManager::RegisterPlugin().

Here is the call graph for this function:

OnPluginValidationFailed()

void PluginStartupRegistration::OnPluginValidationFailed ( const wxString &  providerId, const wxString &  path  )

overridevirtual

Implements AsyncPluginValidator::Delegate.

Definition at line 152 of file PluginStartupRegistration.cpp.

{
   PluginID ID = providerId + wxT("_") + path;
   PluginDescriptor pluginDescriptor;
   pluginDescriptor.SetPluginType(PluginTypeStub);
   pluginDescriptor.SetID(ID);
   pluginDescriptor.SetProviderID(providerId);
   pluginDescriptor.SetPath(path);
   pluginDescriptor.SetEnabled(false);
   pluginDescriptor.SetValid(false);
 
   //Multiple providers can report same module paths
   //do not register until all associated providers have tried to load the module
   mFailedPluginsCache.push_back(std::move(pluginDescriptor));
}

References mFailedPluginsCache, PluginTypeStub, PluginDescriptor::SetEnabled(), PluginDescriptor::SetID(), PluginDescriptor::SetPath(), PluginDescriptor::SetPluginType(), PluginDescriptor::SetProviderID(), PluginDescriptor::SetValid(), and wxT().

Referenced by Skip().

Here is the call graph for this function:

Here is the caller graph for this function:

OnValidationFinished()

void PluginStartupRegistration::OnValidationFinished ( )

overridevirtual

Called when module processing finished.

Implements AsyncPluginValidator::Delegate.

Definition at line 169 of file PluginStartupRegistration.cpp.

{
   ++mCurrentPluginProviderIndex;
   if(mValidProviderFound ||
      mPluginsToProcess[mCurrentPluginIndex].second.size() == mCurrentPluginProviderIndex)
   {
      if(!mFailedPluginsCache.empty())
      {
         //we've tried all providers associated with same module path...
         if(!mValidProviderFound)
         {
            //...but none of them succeeded
            mFailedPluginsPaths.push_back(mFailedPluginsCache[0].GetPath());
 
            //Same plugin path, but different providers, we need to register all of them
            for(auto& desc : mFailedPluginsCache)
               PluginManager::Get().RegisterPlugin(std::move(desc));
         }
         //plugin type was detected, but plugin instance validation has failed
         else
         {
            for(auto& desc : mFailedPluginsCache)
            {
               if(desc.GetPluginType() != PluginTypeStub)
                  mFailedPluginsPaths.push_back(desc.GetPath());
            }
         }
      }
      ++mCurrentPluginIndex;
      mCurrentPluginProviderIndex = 0;
      mValidProviderFound = false;
      mFailedPluginsCache.clear();
   }
   ProcessNext();
}

References anonymous_namespace{ExportPCM.cpp}::desc, PluginManager::Get(), mCurrentPluginIndex, mCurrentPluginProviderIndex, mFailedPluginsCache, mFailedPluginsPaths, mPluginsToProcess, mValidProviderFound, PluginTypeStub, ProcessNext(), and PluginManager::RegisterPlugin().

Referenced by Skip().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessNext()

void PluginStartupRegistration::ProcessNext ( )

private

Definition at line 289 of file PluginStartupRegistration.cpp.

{
   if(mCurrentPluginIndex == mPluginsToProcess.size())
   {
      Stop();
      return;
   }
 
   try
   {
      if(auto dialog = static_cast<PluginScanDialog*>(mScanDialog.get()))
      {
         const auto progress = static_cast<float>(mCurrentPluginIndex) / static_cast<float>(mPluginsToProcess.size());
         dialog->UpdateProgress(
            mPluginsToProcess[mCurrentPluginIndex].first,
            progress);
      }
      if(!mValidator)
         mValidator = std::make_unique<AsyncPluginValidator>(*this);
 
      mValidator->Validate(
         mPluginsToProcess[mCurrentPluginIndex].second[mCurrentPluginProviderIndex],
         mPluginsToProcess[mCurrentPluginIndex].first
      );
      mRequestStartTime = std::chrono::system_clock::now();
      if(auto timer = mTimeoutTimer.get())
         timer->StartOnce(std::chrono::duration_cast<std::chrono::milliseconds>(mTimeout).count());
   }
   catch(std::exception& e)
   {
      StopWithError(e.what());
   }
   catch(...)
   {
      StopWithError("unknown error");
   }
}

References mCurrentPluginIndex, mCurrentPluginProviderIndex, mPluginsToProcess, mRequestStartTime, mScanDialog, mTimeout, mTimeoutTimer, mValidator, Stop(), and StopWithError().

Referenced by OnValidationFinished(), and Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void PluginStartupRegistration::Run

(

std::chrono::seconds

timeout = std::chrono::seconds(30)

)

Starts validation, showing dialog that blocks execution until process is complete or canceled

Parameters

timeout

Time allowed to spend on a single plugin validation. Pass 0 to disable timeout.

Definition at line 210 of file PluginStartupRegistration.cpp.

{
   PluginScanDialog dialog(nullptr, wxID_ANY, XO("Searching for plugins"));
   wxTimer timeoutTimer(&dialog, OnPluginScanTimeout);
   mScanDialog = &dialog;
   mTimeoutTimer = &timeoutTimer;
   mTimeout = timeout;
 
   dialog.Bind(wxEVT_BUTTON, [this](wxCommandEvent& evt) {
      evt.Skip();
      if(evt.GetId() == wxID_IGNORE)
         Skip();
   });
   dialog.Bind(wxEVT_TIMER, [this](wxTimerEvent& evt) {
      if(evt.GetId() == OnPluginScanTimeout)
      {
         if(mValidator && mValidator->InactiveSince() < mRequestStartTime)
            Skip();
         //else
         //   wxMessageBox("Please check for plugin popups!");
      }
      else
         evt.Skip();
   });
   dialog.Bind(wxEVT_CLOSE_WINDOW, [this](wxCloseEvent& evt) {
      evt.Skip();
      mValidator.reset();
      PluginManager::Get().Save();
      PluginManager::Get().NotifyPluginsChanged();
   });
 
   dialog.CenterOnScreen();
   ProcessNext();
   dialog.ShowModal();
}

References PluginManager::Get(), mScanDialog, mTimeout, mTimeoutTimer, mValidator, PluginManager::NotifyPluginsChanged(), anonymous_namespace{PluginStartupRegistration.cpp}::OnPluginScanTimeout, ProcessNext(), PluginManager::Save(), Skip(), and XO().

Here is the call graph for this function:

Skip()

void PluginStartupRegistration::Skip ( )

private

Definition at line 252 of file PluginStartupRegistration.cpp.

{
   //Drop current validator, no more callbacks will be received from now
   mValidator->SetDelegate(nullptr);
   //While on Linux and MacOS socket `shutdown()` wakes up `select()` almost
   //immediately, on Windows it sometimes get delayed on unspecified amount
   //of time. As we do not expect any data we can safely move remaining
   //operations to another thread.
   std::thread([validator = std::shared_ptr<AsyncPluginValidator>(std::move(mValidator))]{ }).detach();
 
   if(!mValidProviderFound)
   {
      // Validator didn't report anything yet or it tried
      // one or more providers that didn't recognize the plugin.
      // In that case we assume that none of the remaining providers
      // can recognize that plugin.
      // Note: create stub `PluginDescriptors` for each associated provider
      for(;mCurrentPluginProviderIndex < mPluginsToProcess[mCurrentPluginIndex].second.size(); ++mCurrentPluginProviderIndex)
         OnPluginValidationFailed(
            mPluginsToProcess[mCurrentPluginIndex].second[mCurrentPluginProviderIndex],
            mPluginsToProcess[mCurrentPluginIndex].first);
      mCurrentPluginProviderIndex = mPluginsToProcess[mCurrentPluginIndex].second.size() - 1;
   }
   //else
   //    Don't assume that `OnValidationFinished()` and `OnPluginFound()`
   //    aren't deferred within run loop
 
   OnValidationFinished();
}

References mCurrentPluginIndex, mCurrentPluginProviderIndex, mPluginsToProcess, mValidator, mValidProviderFound, OnPluginValidationFailed(), and OnValidationFinished().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void PluginStartupRegistration::Stop ( )

private

Definition at line 246 of file PluginStartupRegistration.cpp.

{
   if(auto dialog = mScanDialog.get())
      dialog->Close();
}

References mScanDialog.

Referenced by ProcessNext(), and StopWithError().

Here is the caller graph for this function:

StopWithError()

void PluginStartupRegistration::StopWithError ( const wxString &  msg )

private

Definition at line 282 of file PluginStartupRegistration.cpp.

{
   //TODO: show error dialog?
   wxLogError("Plugin registration error: %s", msg);
   Stop();
}

References Stop().

Referenced by OnInternalError(), and ProcessNext().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mCurrentPluginIndex

size_t PluginStartupRegistration::mCurrentPluginIndex {0}

private

Definition at line 30 of file PluginStartupRegistration.h.

Referenced by OnValidationFinished(), ProcessNext(), and Skip().

mCurrentPluginProviderIndex

size_t PluginStartupRegistration::mCurrentPluginProviderIndex {0}

private

Definition at line 31 of file PluginStartupRegistration.h.

Referenced by OnValidationFinished(), ProcessNext(), and Skip().

mFailedPluginsCache

std::vector<PluginDescriptor> PluginStartupRegistration::mFailedPluginsCache

private

Definition at line 34 of file PluginStartupRegistration.h.

Referenced by OnPluginFound(), OnPluginValidationFailed(), and OnValidationFinished().

mFailedPluginsPaths

std::vector<wxString> PluginStartupRegistration::mFailedPluginsPaths

private

Definition at line 33 of file PluginStartupRegistration.h.

Referenced by GetFailedPluginsPaths(), and OnValidationFinished().

mPluginsToProcess

std::vector<std::pair<wxString, std::vector<wxString> > > PluginStartupRegistration::mPluginsToProcess

private

Definition at line 29 of file PluginStartupRegistration.h.

Referenced by OnValidationFinished(), PluginStartupRegistration(), ProcessNext(), and Skip().

mRequestStartTime

std::chrono::system_clock::time_point PluginStartupRegistration::mRequestStartTime {}

private

Definition at line 38 of file PluginStartupRegistration.h.

Referenced by ProcessNext().

mScanDialog

wxWeakRef<wxDialogWrapper> PluginStartupRegistration::mScanDialog

private

Definition at line 35 of file PluginStartupRegistration.h.

Referenced by ProcessNext(), Run(), and Stop().

mTimeout

std::chrono::system_clock::duration PluginStartupRegistration::mTimeout {}

private

Definition at line 37 of file PluginStartupRegistration.h.

Referenced by ProcessNext(), and Run().

mTimeoutTimer

wxWeakRef<wxTimer> PluginStartupRegistration::mTimeoutTimer

private

Definition at line 36 of file PluginStartupRegistration.h.

Referenced by ProcessNext(), and Run().

mValidator

std::unique_ptr<AsyncPluginValidator> PluginStartupRegistration::mValidator

private

Definition at line 28 of file PluginStartupRegistration.h.

Referenced by ProcessNext(), Run(), and Skip().

mValidProviderFound

bool PluginStartupRegistration::mValidProviderFound {false}

private

Definition at line 32 of file PluginStartupRegistration.h.

Referenced by OnPluginFound(), OnValidationFinished(), and Skip().

---

The documentation for this class was generated from the following files:

• PluginStartupRegistration.h
• PluginStartupRegistration.cpp