#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PluginManager.hpp>

Collaboration diagram for Slic3r::PluginManager:

Classes
struct	ScriptLaunchResult

Public Types
using	PluginLifecycleCompleteFn = std::function<void(const std::string& )>
using	CapabilityLifecycleFn = std::function<void(const PluginCapabilityId&)>
using	ScriptCompletionFn = std::function<void(const ScriptCompletion&)>

Public Member Functions
	~PluginManager ()
bool	initialize ()
void	shutdown ()
void	set_shutting_down ()
bool	is_shutting_down () const
void	discover_plugins (bool async=false, bool clear=false)
void	rescan_plugins ()
PluginConfig &	get_config ()
const PluginConfig &	get_config () const
bool	is_discovery_complete () const
bool	is_discovery_in_progress () const
std::string	get_discovery_error () const
bool	wait_for_discovery (std::chrono::milliseconds timeout, std::string &error) const
std::vector< PluginDescriptor >	get_plugin_descriptors (bool include_invalid=false) const
bool	try_get_plugin_descriptor (const std::string &plugin_key, PluginDescriptor &out) const
bool	try_get_valid_plugin_descriptor (const std::string &plugin_key, PluginDescriptor &out) const
std::vector< PluginDescriptor >	get_missing_plugin_descriptors () const
void	remove_missing_plugins (const std::vector< std::string > &plugin_keys)
std::vector< std::string >	get_enabled_plugin_keys () const
bool	try_get_plugin_descriptor_for_capability (const std::string &capability_name, PluginCapabilityType type, PluginDescriptor &out) const
std::string	get_storage_dir (const std::string &plugin_key) const
std::vector< std::shared_ptr< PluginCapabilityInterface > >	get_plugin_capabilities (const std::string &plugin_key="", PluginCapabilityType type=PluginCapabilityType::Unknown, bool only_enabled=true) const
std::shared_ptr< PluginCapabilityInterface >	get_plugin_capability (const PluginCapabilityId &id, bool only_enabled=true) const
std::shared_ptr< PluginCapabilityInterface >	get_plugin_capability (const std::string &capability_name, PluginCapabilityType type=PluginCapabilityType::Unknown, bool only_enabled=true) const
bool	get_install_state (const std::string &plugin_key, PluginInstallState &install_state)
void	load_plugin (const std::string &plugin_key, bool skip_deps=false, std::vector< std::string > capabilities_to_enable={})
bool	unload_plugin (const std::string &plugin_key)
void	unload_all_plugins ()
void	unload_cloud_plugins ()
bool	is_plugin_loaded (const std::string &plugin_key) const
bool	is_plugin_load_in_progress (const std::string &plugin_key) const
void	wait_for_all_plugin_loads () const
bool	wait_for_all_plugin_loads (std::chrono::milliseconds timeout) const
bool	wait_for_plugin_load (const std::string &plugin_key, std::chrono::milliseconds timeout, std::string &error) const
bool	cancel_plugin_load (const std::string &plugin_key)
std::string	get_plugin_load_error (const std::string &plugin_key) const
void	set_capability_enabled (const PluginCapabilityId &id, bool enabled)
void	set_cloud_user (const std::string &user_id)
void	subscribe_on_load_callback (PluginLifecycleCompleteFn fn)
void	subscribe_on_unload_callback (PluginLifecycleCompleteFn fn)
void	subscribe_on_capability_load_callback (CapabilityLifecycleFn fn)
void	subscribe_on_capability_unload_callback (CapabilityLifecycleFn fn)
void	set_cloud_agent (std::shared_ptr< OrcaCloudServiceAgent > agent)
bool	install_plugin (const boost::filesystem::path &filepath, std::string &error)
bool	install_plugin (const boost::filesystem::path &filepath, PluginDescriptor &plugin_descriptor, std::string &error)
bool	inspect_local_plugin_package (const boost::filesystem::path &filepath, PluginDescriptor &plugin_descriptor, bool &existing_installation, std::string &error) const
bool	set_plugin_error (const std::string &plugin_key, std::string error)
bool	clear_plugin_error (const std::string &plugin_key)
void	fetch_plugins_from_cloud (std::vector< std::string > out_not_found=nullptr, std::vector< std::string > out_unauthorized=nullptr)
void	update_cloud_metadata (const std::vector< PluginDescriptor > &cloud_list)
void	clear_cloud_plugin_metadata ()
bool	download_and_install_cloud_plugin (const std::string &plugin_key, const std::string &version, std::string &error)
bool	subscribe_and_install_cloud_plugin (const std::string &plugin_key, std::string &error)
bool	update_cloud_plugin (const std::string &plugin_key, std::string &error, std::string version="")
bool	delete_plugin (const std::string &plugin_key, std::string &error)
bool	unsubscribe_cloud_plugin (const std::string &plugin_key, std::string &error)
bool	delete_and_unsubscribe_cloud_plugin (const std::string &plugin_key, std::string &error)
ExecutionResult	run_script_capability (const std::string &plugin_key, const std::string &capability_name, std::string &error)
ScriptLaunchResult	launch_script_capability (const std::string &plugin_key, const std::string &capability_name, ScriptCompletionFn on_done={})
void	dispatch_lifecycle_event (LifecycleEvent evt, const LifecycleEventContext &ctx)

Static Public Member Functions
static PluginManager &	instance ()

Private Types
enum class	CallbackType { Load , Unload }

Private Member Functions
	PluginManager ()=default
	PluginManager (const PluginManager &)=delete
PluginManager &	operator= (const PluginManager &)=delete
Plugin *	find_plugin_locked (const std::string &plugin_key)
const Plugin *	find_plugin_locked (const std::string &plugin_key) const
void	load_plugin_impl (const std::string &plugin_key, bool skip_deps, const std::vector< std::string > &capabilities_to_enable)
std::string	check_registry_locked (const std::string &plugin_key, const Plugin &candidate) const
void	run_discovery (bool async, bool clear)
void	run_discovery_task (bool clear)
void	merge_discovered_plugins (std::vector< PluginDescriptor > discovered, bool clear)
void	unload_and_erase_if (const std::function< bool(const Plugin &)> &should_remove, const std::function< void()> &after_erase_locked={})
bool	cancel_plugin_load_locked (const std::string &plugin_key)
bool	is_plugin_load_cancelled_locked (const std::string &plugin_key) const
void	notify_plugin_load_state_changed (bool changed)
void	release_load_slot (const std::string &plugin_key)
void	cancel_and_wait_for_capabilities (const std::vector< std::shared_ptr< PluginCapabilityInterface > > &capabilities)
std::vector< PluginLifecycleCompleteFn >	copy_callbacks (CallbackType type) const
std::vector< CapabilityLifecycleFn >	copy_capability_callbacks (CallbackType type) const
void	run_on_load_callbacks (const std::string &plugin_key)
void	run_on_unload_callbacks (const std::string &plugin_key)
void	run_on_capability_load_callbacks (const PluginCapabilityId &id)
void	run_on_capability_unload_callbacks (const PluginCapabilityId &id)
void	clear_callbacks ()
void	write_loaded_plugin_install_state (const std::string &plugin_key)
void	mark_plugin_install_state_disabled (const std::string &plugin_key)
void	revoke_plugin_permissions (const std::string &plugin_key)
bool	finalize_cloud_plugin_removal (const PluginDescriptor &plugin, bool keep_local, std::string &error)
bool	delete_installed_plugin_package (const PluginDescriptor &plugin, std::string &error)
bool	keep_installed_plugin_as_local (const PluginDescriptor &plugin_descriptor, std::string &error)

Private Attributes
bool	m_initialized = false
CloudPluginService	m_cloud_service
PluginConfig	m_config
std::mutex	m_mutex
std::vector< Plugin >	m_plugins
std::unordered_set< std::string >	m_missing_plugin_keys
std::unordered_set< std::string >	m_load_in_progress
std::unordered_set< std::string >	m_cancelled
std::map< std::string, std::string >	m_load_errors
std::condition_variable	m_load_cv
std::mutex	m_install_state_mutex
std::map< CallbackType, std::vector< PluginLifecycleCompleteFn > >	m_callbacks
std::map< CallbackType, std::vector< CapabilityLifecycleFn > >	m_capability_callbacks
bool	m_discovery_complete = false
bool	m_discovery_in_progress = false
std::string	m_discovery_error
std::condition_variable	m_discovery_cv
std::string	m_cloud_user_id
std::atomic< bool >	m_shutting_down {false}

Detailed Description

Class Documentation

◆ Slic3r::PluginManager::ScriptLaunchResult

struct Slic3r::PluginManager::ScriptLaunchResult

Collaboration diagram for Slic3r::PluginManager::ScriptLaunchResult:

Class Members
bool	launched_async = false
ScriptCompletion	outcome

Member Typedef Documentation

◆ CapabilityLifecycleFn

using Slic3r::PluginManager::CapabilityLifecycleFn = std::function<void(const PluginCapabilityId&)>

◆ PluginLifecycleCompleteFn

using Slic3r::PluginManager::PluginLifecycleCompleteFn = std::function<void(const std::string& )>

◆ ScriptCompletionFn

using Slic3r::PluginManager::ScriptCompletionFn = std::function<void(const ScriptCompletion&)>

Member Enumeration Documentation

◆ CallbackType

enum class Slic3r::PluginManager::CallbackType

strongprivate

Enumerator
Load
Unload

258{ Load, Unload };

Constructor & Destructor Documentation

◆ ~PluginManager()

Slic3r::PluginManager::~PluginManager ( )

85{ shutdown(); }

Slic3r::PluginManager::shutdown

void shutdown()

Definition PluginManager.cpp:150

References shutdown().

Here is the call graph for this function:

◆ PluginManager() [1/2]

Slic3r::PluginManager::PluginManager ( )

privatedefault

Referenced by PluginManager(), instance(), and operator=().

Here is the caller graph for this function:

◆ PluginManager() [2/2]

Slic3r::PluginManager::PluginManager ( const PluginManager & )

privatedelete

References PluginManager().

Here is the call graph for this function:

Member Function Documentation

◆ cancel_and_wait_for_capabilities()

void Slic3r::PluginManager::cancel_and_wait_for_capabilities ( const std::vector< std::shared_ptr< PluginCapabilityInterface > > & capabilities )

private

{
    // Ask the plugin to cancel first, then schedule the async cancellation: on_cancelled() can
    // observe/record state while the run is still intact, and only afterwards is its asyncio task
    // cancelled. Draining of capability references still follows, so the module is not unloaded
    // until the run has settled.
    for (const auto& capability : capabilities) {
        if (!capability || !capability->is_enabled())
            continue;
 
        try {
            capability->on_cancelled();
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(warning) << "Plugin on_cancelled failed for '" << capability->audit_plugin_key() << "/"
                                       << capability->name() << "': " << ex.what();
        } catch (...) {
            BOOST_LOG_TRIVIAL(warning) << "Plugin on_cancelled failed for '" << capability->audit_plugin_key() << "/"
                                       << capability->name() << "'";
        }
    }
 
    for (const auto& capability : capabilities) {
        if (capability)
            ScriptAsyncRuntime::instance().cancel_plugin(capability->audit_plugin_key());
    }
 
    // Script rows are bounded only by their own worker: a cancelled or stalled invocation of another
    // plugin can no longer couple to this one (each invocation owns a thread). A Script worker is
    // drained without a deadline — forcing module unload while one is outstanding would leave Python
    // executing against a freed module, or let a blocking preset selection mutate presets after the
    // plugin is gone. Non-Script synchronous calls keep the historical bounded grace. On the GUI
    // thread the event loop is pumped so a modal selection can settle instead of being starved by a
    // blocking wait.
    const auto grace_deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
    for (;;) {
        const bool all_released = std::all_of(capabilities.begin(), capabilities.end(), [](const auto& capability) {
            return !capability || capability->ref_count() == 0;
        });
        // A cancellation that arrived before the invocation ran skips the ref counter, so an active
        // worker must also be gone: never unload the module while any Script thread is still live.
        const bool invocation_active = std::any_of(capabilities.begin(), capabilities.end(), [](const auto& capability) {
            return capability != nullptr && ScriptAsyncRuntime::instance().has_active_run(capability.get());
        });
        if (all_released && !invocation_active)
            return;
 
        if (!invocation_active && std::chrono::steady_clock::now() >= grace_deadline)
            break;
 
        if (wxTheApp != nullptr && wxIsMainThread())
            wxYield();
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    for (const auto& capability : capabilities) {
        if (!capability)
            continue;
 
        const int refs = capability->ref_count();
        if (refs > 0) {
            BOOST_LOG_TRIVIAL(warning) << "Forcing unload of plugin capability with " << refs
                                       << " active call(s): " << capability->audit_plugin_key() << "/" << capability->name();
        }
    }
}

References Slic3r::ScriptAsyncRuntime::cancel_plugin(), and Slic3r::ScriptAsyncRuntime::instance().

Referenced by unload_all_plugins(), and unload_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel_plugin_load()

bool Slic3r::PluginManager::cancel_plugin_load ( const std::string & plugin_key )

{
    bool cancelled = false;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        cancelled = cancel_plugin_load_locked(plugin_key);
    }
 
    notify_plugin_load_state_changed(cancelled);
    return cancelled;
}

References cancel_plugin_load_locked(), m_mutex, and notify_plugin_load_state_changed().

Here is the call graph for this function:

◆ cancel_plugin_load_locked()

bool Slic3r::PluginManager::cancel_plugin_load_locked ( const std::string & plugin_key )

private

{
    if (m_load_in_progress.count(plugin_key) == 0)
        return false;
 
    m_cancelled.insert(plugin_key);
    m_load_errors.erase(plugin_key);
    return true;
}

References m_cancelled, m_load_errors, and m_load_in_progress.

Referenced by cancel_plugin_load(), and unload_plugin().

Here is the caller graph for this function:

◆ check_registry_locked()

std::string Slic3r::PluginManager::check_registry_locked	(	const std::string &	plugin_key,
		const Plugin &	candidate ) const

private

{
    const Plugin* entry = find_plugin_locked(plugin_key);
    if (entry != nullptr && entry->is_loaded())
        return GUI::format(_u8L("Plugin package is already loaded: %1%"), plugin_key);
 
    // A capability name must be unique per type across every loaded package.
    for (const auto& capability : candidate.capabilities) {
        if (!capability)
            continue;
        for (const Plugin& other : m_plugins) {
            if (!other.is_loaded() || other.descriptor.plugin_key == plugin_key)
                continue;
            for (const auto& existing : other.capabilities) {
                if (existing && existing->type() == capability->type() && existing->name() == capability->name())
                    // TRN %1% is the capability type (e.g. Script), %2% the capability name.
                    return GUI::format(_u8L("Capability collision for type %1% and name '%2%'"),
                                       PluginConfig::capability_type_label(capability->type()), capability->name());
            }
        }
    }
 
    return {};
}

References _u8L, Slic3r::Plugin::capabilities, Slic3r::PluginConfig::capability_type_label(), find_plugin_locked(), Slic3r::GUI::format(), Slic3r::Plugin::is_loaded(), and m_plugins.

Referenced by load_plugin_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_callbacks()

void Slic3r::PluginManager::clear_callbacks ( )

private

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_callbacks.clear();
    m_capability_callbacks.clear();
}

References m_callbacks, m_capability_callbacks, and m_mutex.

Referenced by shutdown().

Here is the caller graph for this function:

◆ clear_cloud_plugin_metadata()

void Slic3r::PluginManager::clear_cloud_plugin_metadata ( )

{
    // Cloud entries may own live Python modules. Unload them before erasing their vector entries,
    // and do so outside m_mutex because both Python teardown and lifecycle callbacks can re-enter
    // the manager.
    unload_and_erase_if(
        [](const Plugin& plugin) { return plugin.descriptor.is_cloud_plugin(); },
        [this]() {
            // A local plugin can still be carrying a stale "not found in the cloud" error from
            // when it was cloud-tracked.
            for (Plugin& plugin : m_plugins) {
                if (plugin.descriptor.normalized_error() == CLOUD_PLUGIN_NOT_FOUND_ERROR)
                    plugin.descriptor.clear_error();
            }
        });
 
    BOOST_LOG_TRIVIAL(info) << "Cleared cloud plugin metadata";
}

References Slic3r::PluginDescriptor::clear_error(), Slic3r::Plugin::descriptor, Slic3r::PluginDescriptor::is_cloud_plugin(), m_plugins, Slic3r::PluginDescriptor::normalized_error(), and unload_and_erase_if().

Referenced by Slic3r::GUI::GUI_App::request_user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_plugin_error()

bool Slic3r::PluginManager::clear_plugin_error ( const std::string & plugin_key )

{
    std::string wait_error;
    if (!wait_for_discovery(std::chrono::milliseconds::max(), wait_error))
        return false;
 
    std::lock_guard<std::mutex> lock(m_mutex);
    Plugin* plugin = find_plugin_locked(plugin_key);
    if (plugin == nullptr || !plugin->descriptor.is_metadata_valid())
        return false;
 
    plugin->descriptor.clear_error();
    return true;
}

References Slic3r::PluginDescriptor::clear_error(), Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::PluginDescriptor::is_metadata_valid(), m_mutex, and wait_for_discovery().

Referenced by download_and_install_cloud_plugin(), install_plugin(), load_plugin(), load_plugin_impl(), Slic3r::GUI::PluginsDialog::run_script_plugin_capability(), Slic3r::GUI::PluginsDialog::toggle_plugin(), and update_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_callbacks()

std::vector< PluginManager::PluginLifecycleCompleteFn > Slic3r::PluginManager::copy_callbacks ( CallbackType type ) const

private

{
    std::lock_guard<std::mutex> lock(m_mutex);
    const auto it = m_callbacks.find(type);
    return it == m_callbacks.end() ? std::vector<PluginLifecycleCompleteFn>{} : it->second;
}

References m_callbacks, and m_mutex.

Referenced by run_on_load_callbacks(), and run_on_unload_callbacks().

Here is the caller graph for this function:

◆ copy_capability_callbacks()

std::vector< PluginManager::CapabilityLifecycleFn > Slic3r::PluginManager::copy_capability_callbacks ( CallbackType type ) const

private

{
    std::lock_guard<std::mutex> lock(m_mutex);
    const auto it = m_capability_callbacks.find(type);
    return it == m_capability_callbacks.end() ? std::vector<CapabilityLifecycleFn>{} : it->second;
}

References m_capability_callbacks, and m_mutex.

Referenced by run_on_capability_load_callbacks(), and run_on_capability_unload_callbacks().

Here is the caller graph for this function:

◆ delete_and_unsubscribe_cloud_plugin()

bool Slic3r::PluginManager::delete_and_unsubscribe_cloud_plugin	(	const std::string &	plugin_key,
		std::string &	error )

{
    if (!wait_for_discovery(std::chrono::milliseconds::max(), error))
        return false;
 
    error.clear();
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        error = GUI::format(_u8L("Plugin not found: %1%"), plugin_key);
        return false;
    }
 
    if (!descriptor.is_cloud_plugin()) {
        error = _u8L("Only cloud plugins can be deleted and unsubscribed.");
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    if (descriptor.cloud->is_mine) {
        error = _u8L("Cannot unsubscribe your own plugins. Use Delete to remove the local files.");
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    unload_plugin(plugin_key);
 
    if (!m_cloud_service.request_cloud_unsubscribe(descriptor, error)) {
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    return finalize_cloud_plugin_removal(descriptor, false, error);
}

References _u8L, Slic3r::PluginDescriptor::cloud, finalize_cloud_plugin_removal(), Slic3r::GUI::format(), Slic3r::PluginDescriptor::is_cloud_plugin(), m_cloud_service, set_plugin_error(), try_get_plugin_descriptor(), unload_plugin(), and wait_for_discovery().

Here is the call graph for this function:

◆ delete_installed_plugin_package()

bool Slic3r::PluginManager::delete_installed_plugin_package	(	const PluginDescriptor &	plugin,
		std::string &	error )

private

{
    boost::filesystem::path resolved_root;
    bool resolved_allowed_plugin_root = false;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        resolved_allowed_plugin_root = resolve_allowed_plugin_root(plugin, get_plugin_directories(m_cloud_user_id),
                                                                   _u8L("Refusing to delete a plugin outside the known plugin directories."),
                                                                   resolved_root, error);
    }
    if (!resolved_allowed_plugin_root)
        return false;
 
    unload_plugin(plugin.plugin_key);
 
    if (!delete_plugin_root(resolved_root, plugin.plugin_key, error))
        return false;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_plugins.erase(std::remove_if(m_plugins.begin(), m_plugins.end(),
                                       [&plugin](const Plugin& entry) { return entry.descriptor.plugin_key == plugin.plugin_key; }),
                        m_plugins.end());
    }
 
    return true;
}

References _u8L, Slic3r::delete_plugin_root(), Slic3r::get_plugin_directories(), m_cloud_user_id, m_mutex, m_plugins, Slic3r::PluginDescriptor::plugin_key, Slic3r::resolve_allowed_plugin_root(), and unload_plugin().

Referenced by delete_plugin(), and finalize_cloud_plugin_removal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_plugin()

bool Slic3r::PluginManager::delete_plugin	(	const std::string &	plugin_key,
		std::string &	error )

{
    if (!wait_for_discovery(std::chrono::milliseconds::max(), error))
        return false;
 
    error.clear();
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        error = GUI::format(_u8L("Plugin not found: %1%"), plugin_key);
        return false;
    }
 
    if (!delete_installed_plugin_package(descriptor, error)) {
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Deleted plugin: " << plugin_key;
    return true;
}

References _u8L, delete_installed_plugin_package(), Slic3r::GUI::format(), set_plugin_error(), try_get_plugin_descriptor(), and wait_for_discovery().

Referenced by Slic3r::GUI::PluginsDialog::delete_local_plugin(), and Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ discover_plugins()

void Slic3r::PluginManager::discover_plugins	(	bool	async = false,
		bool	clear = false )

{
    if (!initialize())
        return;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_discovery_in_progress) {
            BOOST_LOG_TRIVIAL(debug) << "Plugin discovery already running";
            return;
        }
        if (clear) {
            for (Plugin& plugin : m_plugins)
                plugin.descriptor.clear_error();
        }
        m_discovery_in_progress = true;
        m_discovery_complete    = false;
        m_discovery_error.clear();
    }
 
    run_discovery(async, clear);
}

References initialize(), m_discovery_complete, m_discovery_error, m_discovery_in_progress, m_mutex, m_plugins, and run_discovery().

Referenced by Slic3r::GUI::GUI_App::on_init_inner(), and rescan_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispatch_lifecycle_event()

void Slic3r::PluginManager::dispatch_lifecycle_event	(	LifecycleEvent	evt,
		const LifecycleEventContext &	ctx )

                                                                                                 {
    const auto is_canceled = [&ctx]() {
        return ctx.cancellation_check && ctx.cancellation_check();
    };
 
    if (is_canceled())
        return;
 
    for (const auto& cap : get_plugin_capabilities()) {
        if (!cap || !cap->is_enabled()) continue;
        if (is_canceled())
            break;
        try {
            cap->on_lifecycle_event(evt, ctx);
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": plugin '" << cap->audit_plugin_key() << "/" << cap->name()
                                       << "' on_lifecycle_event(" << lifecycle_event_to_string(evt) << ") threw: " << ex.what()
                                       << " [ctx name='" << ctx.name << "', code=" << lifecycle_evt_code_to_string(ctx.code)
                                       << ", msg='" << ctx.msg << "']";
        } catch (...) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": plugin '" << cap->audit_plugin_key() << "/" << cap->name()
                                       << "' on_lifecycle_event(" << lifecycle_event_to_string(evt)
                                       << ") threw a non-standard exception"
                                       << " [ctx name='" << ctx.name << "', code=" << lifecycle_evt_code_to_string(ctx.code)
                                       << ", msg='" << ctx.msg << "']";
        }
    }
}

References Slic3r::LifecycleEventContext::cancellation_check, Slic3r::LifecycleEventContext::code, get_plugin_capabilities(), Slic3r::lifecycle_event_to_string(), Slic3r::lifecycle_evt_code_to_string(), Slic3r::LifecycleEventContext::msg, and Slic3r::LifecycleEventContext::name.

Referenced by Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_lifecycle_event_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ download_and_install_cloud_plugin()

bool Slic3r::PluginManager::download_and_install_cloud_plugin	(	const std::string &	plugin_key,
		const std::string &	version,
		std::string &	error )

{
    error.clear();
 
    CloudPluginDownload download;
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        error = GUI::format(_u8L("Plugin not found: %1%"), plugin_key);
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Failed to find plugin key " << plugin_key;
        return false;
    }
 
    clear_plugin_error(plugin_key);
 
    const std::string requested_version = version.empty() ? descriptor.version : version;
    if (!m_cloud_service.download_cloud_plugin(descriptor, requested_version, download, error)) {
        if (error.empty())
            error = _u8L("Failed to download cloud plugin.");
        set_plugin_error(plugin_key, error);
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": " << error;
        return false;
    }
 
    // Ensure cloud plugins install to _subscribed/<user_id>/
    if (auto agent = m_cloud_service.get_cloud_agent()) {
        const std::string user_id = agent->get_user_id();
        if (!user_id.empty())
            set_cloud_user(user_id);
    }
 
    // Record the version we just fetched from the cloud so install_plugin persists it to the
    // install-state sidecar (the source of truth for the installed cloud version) instead of the
    // local manifest/PEP723 header version.
    descriptor.installed_version = requested_version;
 
    if (!install_plugin(download.package_path, descriptor, error)) {
        if (error.empty())
            error = _u8L("Failed to install cloud plugin.");
        set_plugin_error(plugin_key, error);
        boost::system::error_code ec;
        boost::filesystem::remove(download.package_path, ec);
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": " << error;
        return false;
    }
 
    PluginDescriptor updated_descriptor = descriptor;
    if (!requested_version.empty())
        updated_descriptor.version = requested_version;
    // The version just downloaded and installed is now the locally installed version.
    updated_descriptor.installed_version = requested_version.empty() ? descriptor.version : requested_version;
    updated_descriptor.enabled = true;
    if (updated_descriptor.cloud.has_value()) {
        updated_descriptor.cloud->installed        = true;
        updated_descriptor.cloud->update_available = false;
        updated_descriptor.cloud->unauthorized     = false;
    }
    updated_descriptor.clear_error();
    updated_descriptor.set_unauthorized(false);
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        Plugin* entry = find_plugin_locked(plugin_key);
        if (entry == nullptr) {
            error = _u8L("Plugin not found.");
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Cloud plugin " << plugin_key
                                       << " downloaded successfully but failed to update plugin metadata. Plugin object not found.";
        } else {
            entry->descriptor = std::move(updated_descriptor);
        }
    }
    if (!error.empty()) {
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Cloud plugin " << plugin_key << " installed successfully";
    return true;
}

References _u8L, Slic3r::PluginDescriptor::clear_error(), clear_plugin_error(), Slic3r::PluginDescriptor::cloud, Slic3r::Plugin::descriptor, Slic3r::PluginDescriptor::enabled, find_plugin_locked(), Slic3r::GUI::format(), install_plugin(), Slic3r::PluginDescriptor::installed_version, m_cloud_service, m_mutex, Slic3r::CloudPluginDownload::package_path, set_cloud_user(), set_plugin_error(), Slic3r::PluginDescriptor::set_unauthorized(), try_get_plugin_descriptor(), and Slic3r::PluginDescriptor::version.

Referenced by Slic3r::GUI::PluginsDialog::install_cloud_plugin(), subscribe_and_install_cloud_plugin(), and update_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fetch_plugins_from_cloud()

void Slic3r::PluginManager::fetch_plugins_from_cloud	(	std::vector< std::string > *	out_not_found = nullptr,
		std::vector< std::string > *	out_unauthorized = nullptr )

{
    if (!m_cloud_service.can_fetch_cloud_plugins())
        return;
 
    std::vector<PluginDescriptor> cloud_list{};
    std::vector<std::string> not_found{}, unauthorized{};
    const bool cloud_fetch_succeeded = m_cloud_service.fetch_manifests_into_descriptors(cloud_list, not_found, unauthorized);
    if (!cloud_fetch_succeeded) {
        if (wxTheApp != nullptr) {
            GUI::wxGetApp().CallAfter([] {
                if (GUI::wxGetApp().is_closing())
                    return;
                GUI::Plater* plater = GUI::wxGetApp().plater();
                if (plater == nullptr || GUI::wxGetApp().imgui() == nullptr || !GUI::wxGetApp().imgui()->display_initialized())
                    return;
                plater->get_notification_manager()->push_notification(GUI::NotificationType::CustomNotification,
                                                                      GUI::NotificationManager::NotificationLevel::WarningNotificationLevel,
                                                                      _u8L("Failed to fetch plugins from the cloud. See logs for details."));
            });
        }
    }
 
    if (cloud_fetch_succeeded)
        update_cloud_metadata(cloud_list);
 
    if (cloud_fetch_succeeded) {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        // Clear the previous cloud verdicts before re-applying the fresh ones.
        for (Plugin& plugin : m_plugins) {
            PluginDescriptor& entry = plugin.descriptor;
            if (!entry.is_cloud_plugin())
                continue;
            entry.set_unauthorized(false);
            if (entry.cloud.has_value())
                entry.cloud->orphaned = false;
            if (entry.normalized_error() == CLOUD_PLUGIN_NOT_FOUND_ERROR)
                entry.clear_error();
        }
 
        // A successful subscriptions response may report missing UUIDs explicitly, or it may
        // simply omit an unsubscribed plugin from `data`. Both cases leave a locally retained
        // cloud package orphaned. Owned plugins are returned by the separate mine endpoint and
        // must not be orphaned merely because they are not subscribed.
        for (Plugin& plugin : m_plugins) {
            PluginDescriptor& entry = plugin.descriptor;
            if (!entry.is_cloud_plugin() || entry.cloud->is_mine)
                continue;
 
            const bool explicitly_not_found = std::find(not_found.begin(), not_found.end(), entry.cloud_uuid()) != not_found.end();
            const bool returned_by_cloud = std::any_of(cloud_list.begin(), cloud_list.end(), [&entry](const PluginDescriptor& cloud_entry) {
                return cloud_entry.cloud_uuid() == entry.cloud_uuid();
            });
            entry.cloud->orphaned = explicitly_not_found || !returned_by_cloud;
            if (entry.cloud->orphaned)
                entry.cloud->update_available = false;
        }
 
        for (const std::string& uuid : unauthorized) {
            for (Plugin& plugin : m_plugins) {
                PluginDescriptor& entry = plugin.descriptor;
                if (!entry.is_cloud_plugin() || entry.cloud_uuid() != uuid)
                    continue;
                entry.set_unauthorized(true);
                if (entry.cloud.has_value())
                    entry.cloud->update_available = false;
                break;
            }
        }
    }
 
    if (out_not_found)
        *out_not_found = std::move(not_found);
    if (out_unauthorized)
        *out_unauthorized = std::move(unauthorized);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Cloud plugin fetch: " << cloud_list.size() << " plugins returned";
}

References _u8L, Slic3r::PluginDescriptor::clear_error(), Slic3r::PluginDescriptor::cloud, Slic3r::PluginDescriptor::cloud_uuid(), Slic3r::GUI::CustomNotification, Slic3r::GUI::Plater::get_notification_manager(), Slic3r::PluginDescriptor::is_cloud_plugin(), m_cloud_service, m_mutex, m_plugins, Slic3r::PluginDescriptor::normalized_error(), Slic3r::GUI::NotificationManager::push_notification(), Slic3r::PluginDescriptor::set_unauthorized(), update_cloud_metadata(), and Slic3r::GUI::NotificationManager::WarningNotificationLevel.

Referenced by finalize_cloud_plugin_removal(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::refresh_plugin_metadata_blocking(), and subscribe_and_install_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize_cloud_plugin_removal()

bool Slic3r::PluginManager::finalize_cloud_plugin_removal	(	const PluginDescriptor &	plugin,
		bool	keep_local,
		std::string &	error )

private

{
    if (keep_local && plugin.has_local_package()) {
        if (!keep_installed_plugin_as_local(plugin, error))
            return false;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Removed cloud tracking, kept local copy: " << plugin.plugin_key;
        return true;
    }
 
    if (plugin.has_local_package()) {
        if (!delete_installed_plugin_package(plugin, error))
            return false;
 
        fetch_plugins_from_cloud();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Deleted local package after cloud removal: " << plugin.plugin_key;
        return true;
    }
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_plugins.erase(std::remove_if(m_plugins.begin(), m_plugins.end(),
                                       [&plugin](const Plugin& entry) { return entry.descriptor.plugin_key == plugin.plugin_key; }),
                        m_plugins.end());
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Removed cloud-only plugin: " << plugin.plugin_key;
    return true;
}

References delete_installed_plugin_package(), fetch_plugins_from_cloud(), Slic3r::PluginDescriptor::has_local_package(), keep_installed_plugin_as_local(), m_mutex, m_plugins, and Slic3r::PluginDescriptor::plugin_key.

Referenced by delete_and_unsubscribe_cloud_plugin(), and unsubscribe_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_plugin_locked() [1/2]

Plugin * Slic3r::PluginManager::find_plugin_locked ( const std::string & plugin_key )

private

{
    const auto it = std::find_if(m_plugins.begin(), m_plugins.end(),
                                 [&plugin_key](const Plugin& plugin) { return plugin.descriptor.plugin_key == plugin_key; });
    return it == m_plugins.end() ? nullptr : &*it;
}

References m_plugins.

Referenced by check_registry_locked(), clear_plugin_error(), download_and_install_cloud_plugin(), get_plugin_capability(), is_plugin_loaded(), keep_installed_plugin_as_local(), load_plugin(), load_plugin_impl(), mark_plugin_install_state_disabled(), merge_discovered_plugins(), set_capability_enabled(), set_plugin_error(), try_get_plugin_descriptor(), try_get_valid_plugin_descriptor(), unload_plugin(), and write_loaded_plugin_install_state().

Here is the caller graph for this function:

◆ find_plugin_locked() [2/2]

const Plugin * Slic3r::PluginManager::find_plugin_locked ( const std::string & plugin_key ) const

private

{
    const auto it = std::find_if(m_plugins.begin(), m_plugins.end(),
                                 [&plugin_key](const Plugin& plugin) { return plugin.descriptor.plugin_key == plugin_key; });
    return it == m_plugins.end() ? nullptr : &*it;
}

References m_plugins.

◆ get_config() [1/2]

PluginConfig & Slic3r::PluginManager::get_config ( )

inline

139{ return m_config; }

Slic3r::PluginManager::m_config

PluginConfig m_config

Definition PluginManager.hpp:310

References m_config.

Referenced by Slic3r::capability_save_config(), and Slic3r::PresetPluginConfigService::get_effective_config().

Here is the caller graph for this function:

◆ get_config() [2/2]

const PluginConfig & Slic3r::PluginManager::get_config ( ) const

inline

140{ return m_config; }

References m_config.

◆ get_discovery_error()

std::string Slic3r::PluginManager::get_discovery_error ( ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_discovery_error;
}

References m_discovery_error, and m_mutex.

◆ get_enabled_plugin_keys()

std::vector< std::string > Slic3r::PluginManager::get_enabled_plugin_keys ( ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    std::vector<std::string> keys;
    for (const Plugin& plugin : m_plugins) {
        if (plugin.descriptor.enabled && plugin.descriptor.has_local_package())
            keys.push_back(plugin.descriptor.plugin_key);
    }
    return keys;
}

References m_mutex, and m_plugins.

Referenced by Slic3r::GUI::GUI_App::on_init_inner().

Here is the caller graph for this function:

◆ get_install_state()

bool Slic3r::PluginManager::get_install_state	(	const std::string &	plugin_key,
		PluginInstallState &	install_state )

{
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        return false;
    }
 
    if (!read_install_state(boost::filesystem::path(descriptor.plugin_root), install_state)) {
        return false;
    }
 
    return true;
}

References Slic3r::PluginDescriptor::plugin_root, Slic3r::read_install_state(), and try_get_plugin_descriptor().

Referenced by Slic3r::PluginAuditDetail::audit_plugin_event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_missing_plugin_descriptors()

std::vector< PluginDescriptor > Slic3r::PluginManager::get_missing_plugin_descriptors ( ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    std::vector<PluginDescriptor> result;
    result.reserve(m_missing_plugin_keys.size());
    for (const Plugin& plugin : m_plugins)
        if (m_missing_plugin_keys.count(plugin.descriptor.plugin_key) != 0)
            result.push_back(plugin.descriptor);
    return result;
}

References m_missing_plugin_keys, m_mutex, and m_plugins.

Referenced by Slic3r::GUI::PluginsDialog::prompt_for_missing_plugins().

Here is the caller graph for this function:

◆ get_plugin_capabilities()

std::vector< std::shared_ptr< PluginCapabilityInterface > > Slic3r::PluginManager::get_plugin_capabilities	(	const std::string &	plugin_key = "",
		PluginCapabilityType	type = PluginCapabilityType::Unknown,
		bool	only_enabled = true ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    std::vector<std::shared_ptr<PluginCapabilityInterface>> result;
    for (const Plugin& plugin : m_plugins) {
        if (!plugin_key.empty() && plugin.descriptor.plugin_key != plugin_key)
            continue;
 
        for (const auto& capability : plugin.capabilities) {
            if (!capability)
                continue;
            if (type != PluginCapabilityType::Unknown && capability->type() != type)
                continue;
            if (only_enabled && !capability->is_enabled())
                continue;
            result.push_back(capability);
        }
    }
    return result;
}

References m_mutex, m_plugins, and Slic3r::Unknown.

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_dialog_item(), dispatch_lifecycle_event(), Slic3r::GUI::ActionRegistry::init(), Slic3r::GUI::OptionsGroup::pick_plugin(), Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::primary_capability_type_of(), and Slic3r::GUI::ActionRegistry::refresh_source().

Here is the caller graph for this function:

◆ get_plugin_capability() [1/2]

std::shared_ptr< PluginCapabilityInterface > Slic3r::PluginManager::get_plugin_capability	(	const PluginCapabilityId &	id,
		bool	only_enabled = true ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    const Plugin* plugin = find_plugin_locked(id.plugin_key);
    if (plugin == nullptr)
        return nullptr;
 
    for (const auto& capability : plugin->capabilities) {
        if (!capability || capability->name() != id.name)
            continue;
        if (id.type != PluginCapabilityType::Unknown && capability->type() != id.type)
            continue;
        if (only_enabled && !capability->is_enabled())
            continue;
        return capability;
    }
 
    return nullptr;
}

References Slic3r::Plugin::capabilities, find_plugin_locked(), m_mutex, and Slic3r::Unknown.

Referenced by Slic3r::PluginResourceTextures::build_entry(), Slic3r::PluginConfig::capabilities_payload(), Slic3r::execute_capabilities_from_refs(), Slic3r::PluginConfig::get_config_response(), Slic3r::PluginPages::get_pages_cap(), Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_capability_resolver(), launch_script_capability(), Slic3r::loaded_capability_state(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::make_action(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::make_page_action(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), Slic3r::PluginConfig::restore_config_response(), Slic3r::PluginConfig::save_config_response(), and Slic3r::GUI::PluginsConfigDialog::send_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_plugin_capability() [2/2]

std::shared_ptr< PluginCapabilityInterface > Slic3r::PluginManager::get_plugin_capability	(	const std::string &	capability_name,
		PluginCapabilityType	type = PluginCapabilityType::Unknown,
		bool	only_enabled = true ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    for (const Plugin& plugin : m_plugins) {
        for (const auto& capability : plugin.capabilities) {
            if (!capability || capability->name() != capability_name)
                continue;
            if (type != PluginCapabilityType::Unknown && capability->type() != type)
                continue;
            if (only_enabled && !capability->is_enabled())
                continue;
            return capability;
        }
    }
 
    return nullptr;
}

References m_mutex, m_plugins, and Slic3r::Unknown.

◆ get_plugin_descriptors()

std::vector< PluginDescriptor > Slic3r::PluginManager::get_plugin_descriptors ( bool include_invalid = false ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    std::vector<PluginDescriptor> result;
    result.reserve(m_plugins.size());
    for (const Plugin& plugin : m_plugins) {
        if (!include_invalid && plugin.descriptor.is_invalid_package())
            continue;
        result.push_back(plugin.descriptor);
    }
    return result;
}

References m_mutex, and m_plugins.

Referenced by Slic3r::GUI::PluginsDialog::build_plugins_payload(), and Slic3r::GUI::ActionRegistry::init().

Here is the caller graph for this function:

◆ get_plugin_load_error()

std::string Slic3r::PluginManager::get_plugin_load_error ( const std::string & plugin_key ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    const auto it = m_load_errors.find(plugin_key);
    return it == m_load_errors.end() ? std::string{} : it->second;
}

References m_load_errors, and m_mutex.

◆ get_storage_dir()

std::string Slic3r::PluginManager::get_storage_dir ( const std::string & plugin_key ) const

{
    namespace fs = boost::filesystem;
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor))
        throw std::runtime_error("The current plugin is not registered");
 
    const fs::path base_storage_dir = fs::path(get_orca_plugins_dir()) / PLUGIN_DATA_DIR;
 
    if (!descriptor.is_cloud_plugin()) {
        const fs::path local_storage_dir = base_storage_dir / plugin_key;
        fs::create_directories(local_storage_dir);
        return local_storage_dir.string();
    }
 
    auto agent = m_cloud_service.get_cloud_agent();
    if (!agent)
        throw std::runtime_error("Cloud plugin storage is unavailable before networking is initialized");
 
    const std::string user_id = agent->get_user_id();
    if (user_id.empty())
        throw std::runtime_error("Cloud plugin storage is unavailable without a logged-in user");
 
    if (!is_valid_plugin_id(plugin_key))
        throw std::runtime_error("The current cloud plugin key is not a valid folder name");
 
    const fs::path cloud_storage_dir = base_storage_dir / PLUGIN_SUBSCRIBED_DIR / user_id / plugin_key;
    fs::create_directories(cloud_storage_dir);
    return cloud_storage_dir.string();
}

References Slic3r::get_orca_plugins_dir(), Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::is_valid_plugin_id(), m_cloud_service, PLUGIN_DATA_DIR, PLUGIN_SUBSCRIBED_DIR, and try_get_plugin_descriptor().

Referenced by Slic3r::host_bindings::register_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize()

bool Slic3r::PluginManager::initialize ( )

{
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_initialized)
            return true;
        m_shutting_down.store(false, std::memory_order_release);
    }
 
    // Initialize the Python interpreter eagerly on the main thread. CPython must be initialized
    // from the main thread; calling Py_InitializeFromConfig from a background thread (e.g. the
    // load_plugin worker) causes heap corruption in CPython internals.
    PythonInterpreter& interpreter = PythonInterpreter::instance();
    if (!interpreter.is_initialized() && !interpreter.initialize()) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Failed to initialize Python interpreter: " << interpreter.last_error();
        return false;
    }
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_initialized)
            return true;
        m_initialized = true;
    }
 
    // Re-arm the async Script runtime in case shutdown() ran earlier in this process.
    ScriptAsyncRuntime::instance().reset();
 
    // Bring every capability's stored config into memory. Deliberately unconditional and
    // independent of which plugins are installed: an entry outlives uninstall/unsubscribe, so a
    // plugin that comes back later finds its settings intact. A missing or malformed file just
    // leaves the store empty (see PluginConfig::load), never blocking startup.
    m_config.load();
 
    // Install the libslic3r hooks (capability resolver, slicing-pipeline dispatcher).
    // Uninstalled in shutdown() before the interpreter finalizes.
    plugin_hooks::install();
 
    // Persist auto-load / capability state to each plugin's .install_state.json sidecar.
    // On load: write enabled=true plus the current capability flags. On unload: flip enabled=false.
    // The on-unload callback is skipped during shutdown, so app exit does not wipe the auto-load list.
    subscribe_on_load_callback([this](const std::string& key) { write_loaded_plugin_install_state(key); });
    subscribe_on_unload_callback([this](const std::string& key) {
        if (m_shutting_down.load(std::memory_order_acquire))
            return;
        PluginDescriptor descriptor;
        if (!try_get_plugin_descriptor(key, descriptor) || descriptor.plugin_root.empty())
            return;
        const boost::filesystem::path root(descriptor.plugin_root);
        PluginInstallState state;
        if (read_install_state(root, state)) {
            state.enabled = false;
            write_install_state(root, state);
        }
    });
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Plugin manager initialized";
 
    return true;
}

References Slic3r::PluginInstallState::enabled, Slic3r::PythonInterpreter::initialize(), Slic3r::plugin_hooks::install(), Slic3r::PythonInterpreter::instance(), Slic3r::ScriptAsyncRuntime::instance(), Slic3r::PythonInterpreter::is_initialized(), Slic3r::PythonInterpreter::last_error(), m_config, m_initialized, m_mutex, m_shutting_down, Slic3r::PluginDescriptor::plugin_root, Slic3r::read_install_state(), Slic3r::ScriptAsyncRuntime::reset(), subscribe_on_load_callback(), subscribe_on_unload_callback(), try_get_plugin_descriptor(), Slic3r::write_install_state(), and write_loaded_plugin_install_state().

Referenced by discover_plugins(), and Slic3r::GUI::GUI_App::on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inspect_local_plugin_package()

bool Slic3r::PluginManager::inspect_local_plugin_package	(	const boost::filesystem::path &	filepath,
		PluginDescriptor &	plugin_descriptor,
		bool &	existing_installation,
		std::string &	error ) const

1432{ return plugin_loader::inspect_local_plugin_package(filepath, plugin_descriptor, existing_installation, error); }

Slic3r::plugin_loader::inspect_local_plugin_package

bool inspect_local_plugin_package(const boost::filesystem::path &filepath, PluginDescriptor &plugin_descriptor, bool &existing_installation, std::string &error)

Definition PluginLoader.cpp:588

References Slic3r::plugin_loader::inspect_local_plugin_package().

Here is the call graph for this function:

◆ install_plugin() [1/2]

bool Slic3r::PluginManager::install_plugin	(	const boost::filesystem::path &	filepath,
		PluginDescriptor &	plugin_descriptor,
		std::string &	error )

{
    error.clear();
 
    std::string wait_error;
    if (!wait_for_discovery(std::chrono::milliseconds::max(), wait_error)) {
        error = wait_error.empty() ? "Plugin discovery is still running" : wait_error;
        if (!plugin_descriptor.plugin_key.empty())
            set_plugin_error(plugin_descriptor.plugin_key, error);
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Plugin installation failed while waiting for discovery: " << error;
        return false;
    }
 
    std::string cloud_user_id;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        cloud_user_id = m_cloud_user_id;
    }
 
    // A local overwrite must not leave the old module holding the package file or its Python
    // namespace while the installer replaces the package on disk.
    if (!plugin_descriptor.is_cloud_plugin()) {
        const std::string local_plugin_key = make_local_plugin_key(filepath.stem().string());
        if (is_plugin_loaded(local_plugin_key))
            unload_plugin(local_plugin_key);
    }
 
    if (!plugin_loader::install_plugin(filepath, cloud_user_id, plugin_descriptor, error)) {
        if (!plugin_descriptor.plugin_key.empty())
            set_plugin_error(plugin_descriptor.plugin_key, error);
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": " << error;
        return false;
    }
 
    // Every successful install may have replaced executable plugin code. Revoke any permissions
    // associated with the previous package so the newly installed version must request them again.
    if (!plugin_descriptor.plugin_key.empty())
        revoke_plugin_permissions(plugin_descriptor.plugin_key);
 
    if (!plugin_descriptor.plugin_key.empty())
        clear_plugin_error(plugin_descriptor.plugin_key);
 
    return true;
}

References clear_plugin_error(), Slic3r::plugin_loader::install_plugin(), Slic3r::PluginDescriptor::is_cloud_plugin(), is_plugin_loaded(), m_cloud_user_id, m_mutex, Slic3r::make_local_plugin_key(), Slic3r::PluginDescriptor::plugin_key, revoke_plugin_permissions(), set_plugin_error(), unload_plugin(), and wait_for_discovery().

Here is the call graph for this function:

◆ install_plugin() [2/2]

bool Slic3r::PluginManager::install_plugin	(	const boost::filesystem::path &	filepath,
		std::string &	error )

{
    PluginDescriptor descriptor{};
    return install_plugin(filepath, descriptor, error);
}

References install_plugin().

Referenced by download_and_install_cloud_plugin(), Slic3r::GUI::install_local_plugin_package(), and install_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ instance()

PluginManager & Slic3r::PluginManager::instance ( )

static

{
    // Touch the interpreter first so its static outlives this one: ~Plugin needs it alive to
    // release module, sys.modules, and sys.path ownership safely. Touch the async Script runtime
    // next, so ~PluginManager can still drain it during its own shutdown().
    PythonInterpreter::instance();
    ScriptAsyncRuntime::instance();
    static PluginManager inst;
    return inst;
}

References PluginManager(), Slic3r::PythonInterpreter::instance(), and Slic3r::ScriptAsyncRuntime::instance().

Here is the call graph for this function:

◆ is_discovery_complete()

bool Slic3r::PluginManager::is_discovery_complete ( ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_discovery_complete;
}

References m_discovery_complete, and m_mutex.

◆ is_discovery_in_progress()

bool Slic3r::PluginManager::is_discovery_in_progress ( ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_discovery_in_progress;
}

References m_discovery_in_progress, and m_mutex.

◆ is_plugin_load_cancelled_locked()

bool Slic3r::PluginManager::is_plugin_load_cancelled_locked ( const std::string & plugin_key ) const

private

750{ return m_cancelled.count(plugin_key) > 0; }

References m_cancelled.

Referenced by load_plugin_impl().

Here is the caller graph for this function:

◆ is_plugin_load_in_progress()

bool Slic3r::PluginManager::is_plugin_load_in_progress ( const std::string & plugin_key ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_load_in_progress.count(plugin_key) > 0;
}

References m_load_in_progress, and m_mutex.

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_dialog_item(), Slic3r::GUI::PluginsDialog::resolve_pending_activation(), and Slic3r::GUI::PluginsDialog::toggle_plugin().

Here is the caller graph for this function:

◆ is_plugin_loaded()

bool Slic3r::PluginManager::is_plugin_loaded ( const std::string & plugin_key ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    const Plugin* plugin = find_plugin_locked(plugin_key);
    return plugin != nullptr && plugin->is_loaded();
}

References find_plugin_locked(), Slic3r::Plugin::is_loaded(), and m_mutex.

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_dialog_item(), install_plugin(), Slic3r::loaded_capability_state(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::make_action(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::make_page_action(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::refresh_missing_plugins(), Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::resolve_missing_plugins(), Slic3r::GUI::PluginsDialog::resolve_pending_activation(), and Slic3r::GUI::PluginsDialog::toggle_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_shutting_down()

bool Slic3r::PluginManager::is_shutting_down ( ) const

inline

133{ return m_shutting_down.load(std::memory_order_acquire); }

References m_shutting_down.

◆ keep_installed_plugin_as_local()

bool Slic3r::PluginManager::keep_installed_plugin_as_local	(	const PluginDescriptor &	plugin_descriptor,
		std::string &	error )

private

{
    namespace fs = boost::filesystem;
 
    boost::filesystem::path resolved_root;
 
    bool resolved_allowed_plugin_root = false;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        resolved_allowed_plugin_root = resolve_allowed_plugin_root(plugin_descriptor, get_plugin_directories(m_cloud_user_id),
                                                                   _u8L("Refusing to update a plugin outside the known plugin directories."),
                                                                   resolved_root, error);
    }
 
    if (!resolved_allowed_plugin_root)
        return false;
 
    const std::string old_key = plugin_descriptor.plugin_key;
 
    // Generate a new local key from the entry file stem (cloud -> local conversion).
    const std::string entry_stem = fs::path(plugin_descriptor.entry_path).stem().string();
    const std::string new_key    = make_local_plugin_key(!entry_stem.empty() ? entry_stem : resolved_root.stem().string());
 
    PluginDescriptor local_descriptor = plugin_descriptor;
    local_descriptor.plugin_key       = new_key;
    local_descriptor.cloud            = std::nullopt;
    local_descriptor.clear_error();
 
    // Re-key the entry in place, carrying the live module/capabilities (if any) with it. The
    // capabilities' audit key must follow, since it is what identifies their owning package.
    std::vector<PluginCapabilityId> rekeyed;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        Plugin* entry = find_plugin_locked(old_key);
        if (entry == nullptr) {
            error = GUI::format(_u8L("Plugin manifest not found: %1%"), old_key);
            return false;
        }
 
        if (find_plugin_locked(new_key) != nullptr && new_key != old_key) {
            error = GUI::format(_u8L("Cannot keep plugin local: local plugin key already exists: %1%"), new_key);
            BOOST_LOG_TRIVIAL(warning) << error;
            return false;
        }
 
        // Preserve the sidecar's package and capability choices while changing only its origin.
        // Re-keying an installed plugin must not silently re-enable capabilities.
        PluginInstallState install_state;
        if (!read_install_state(resolved_root, install_state)) {
            install_state.installed_version = !local_descriptor.installed_version.empty()
                                                  ? local_descriptor.installed_version
                                                  : local_descriptor.version;
            install_state.enabled = local_descriptor.enabled;
        }
        install_state.installed_from = "local";
        install_state.plugin_name    = local_descriptor.name;
        install_state.cloud_uuid.clear();
        if (install_state.installed_version.empty())
            install_state.installed_version = local_descriptor.version;
        if (!write_install_state(resolved_root, install_state)) {
            error = GUI::format(_u8L("Failed to update plugin install state: %1%"), (resolved_root / INSTALL_STATE_FILE).string());
            return false;
        }
 
        entry->descriptor.plugin_key = new_key;
        entry->descriptor.cloud.reset();
        entry->descriptor.clear_error();
 
        for (const auto& capability : entry->capabilities) {
            if (capability)
                capability->set_audit_plugin_key(new_key);
        }
 
        for (const auto& capability : entry->capabilities) {
            if (capability && capability->is_enabled())
                rekeyed.push_back(PluginCapabilityId{capability->type(), capability->name(), new_key});
        }
    }
 
    // Subscribers key their own state by plugin_key. Publish the identity transition after the
    // registry update and outside m_mutex so they can safely query the manager.
    for (const PluginCapabilityId& id : rekeyed) {
        run_on_capability_unload_callbacks(PluginCapabilityId{id.type, id.name, old_key});
        run_on_capability_load_callbacks(id);
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Transitioned plugin from " << old_key << " to " << new_key;
 
    return true;
}

References _u8L, Slic3r::Plugin::capabilities, Slic3r::PluginDescriptor::clear_error(), Slic3r::PluginDescriptor::cloud, Slic3r::PluginInstallState::cloud_uuid, Slic3r::Plugin::descriptor, Slic3r::PluginDescriptor::enabled, Slic3r::PluginInstallState::enabled, Slic3r::PluginDescriptor::entry_path, find_plugin_locked(), Slic3r::GUI::format(), Slic3r::get_plugin_directories(), Slic3r::INSTALL_STATE_FILE, Slic3r::PluginInstallState::installed_from, Slic3r::PluginDescriptor::installed_version, Slic3r::PluginInstallState::installed_version, m_cloud_user_id, m_mutex, Slic3r::make_local_plugin_key(), Slic3r::PluginDescriptor::name, Slic3r::PluginDescriptor::plugin_key, Slic3r::PluginInstallState::plugin_name, Slic3r::read_install_state(), Slic3r::resolve_allowed_plugin_root(), run_on_capability_load_callbacks(), run_on_capability_unload_callbacks(), Slic3r::PluginDescriptor::version, and Slic3r::write_install_state().

Referenced by finalize_cloud_plugin_removal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ launch_script_capability()

PluginManager::ScriptLaunchResult Slic3r::PluginManager::launch_script_capability	(	const std::string &	plugin_key,
		const std::string &	capability_name,
		ScriptCompletionFn	on_done = {} )

{
    ScriptLaunchResult launch;
 
    // Mirror the historical synchronous behavior for a dangling reference: nothing to run and
    // no error (the caller's guarded UI normally prevents this).
    if (plugin_key.empty() || capability_name.empty())
        return launch;
 
    if (m_shutting_down.load(std::memory_order_acquire)) {
        launch.outcome.error = _u8L("Plugin system is shutting down.");
        return launch;
    }
 
    auto cap = get_plugin_capability({PluginCapabilityType::Script, capability_name, plugin_key});
    if (!cap)
        return launch;
 
    if (!std::dynamic_pointer_cast<ScriptPluginCapability>(cap))
        return launch;
 
    // Every Script body runs off the caller's thread now: the invocation — including detection and
    // a synchronous `def execute` — is handed to the runtime, which runs it on its own worker and
    // reports the outcome through the completion callback. Nothing executes before returning here,
    // so the UI thread is never blocked by a Script invocation.
    const bool started = ScriptAsyncRuntime::instance().start(
        plugin_key, capability_name, cap,
        [this, plugin_key, on_done](const ScriptCompletion& completion) {
            // A cancellation requested by cancel_plugin() (unload/shutdown) is expected termination:
            // record no plugin error and surface nothing. Genuine user/plugin errors still record.
            if (!completion.cancelled && !completion.error.empty())
                set_plugin_error(plugin_key, completion.error);
            if (on_done)
                on_done(completion);
        });
 
    if (!started) {
        launch.outcome.error = _u8L("Plugin system is shutting down.");
        set_plugin_error(plugin_key, launch.outcome.error);
        BOOST_LOG_TRIVIAL(error) << "Script plugin execution failed. plugin_key=" << plugin_key
                                 << " error=" << launch.outcome.error;
        return launch;
    }
 
    launch.launched_async = true;
    return launch;
}

References _u8L, Slic3r::ScriptCompletion::cancelled, Slic3r::ScriptCompletion::error, get_plugin_capability(), Slic3r::ScriptAsyncRuntime::instance(), Slic3r::PluginManager::ScriptLaunchResult::launched_async, m_shutting_down, Slic3r::PluginManager::ScriptLaunchResult::outcome, Slic3r::Script, set_plugin_error(), and Slic3r::ScriptAsyncRuntime::start().

Referenced by run_script_capability(), and Slic3r::GUI::PluginsDialog::run_script_plugin_capability().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_plugin()

void Slic3r::PluginManager::load_plugin	(	const std::string &	plugin_key,
		bool	skip_deps = false,
		std::vector< std::string >	capabilities_to_enable = {} )

{
    std::string plugin_id = plugin_key;
 
    bool exists           = false;
    bool invalid          = false;
    bool already_loaded   = false;
    bool load_in_progress = false;
    bool load_slot_claimed = false;
    bool shutting_down     = false;
    std::string invalid_error;
    std::vector<std::string> loaded_capability_names;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        const Plugin* plugin = find_plugin_locked(plugin_key);
        if (plugin != nullptr) {
            exists         = true;
            plugin_id      = plugin->descriptor.plugin_key;
            invalid        = plugin->descriptor.is_invalid_package();
            already_loaded = plugin->is_loaded();
            invalid_error  = plugin->descriptor.normalized_error();
            if (already_loaded) {
                for (const auto& capability : plugin->capabilities)
                    if (capability)
                        loaded_capability_names.push_back(capability->name());
            }
        }
 
        load_in_progress = m_load_in_progress.count(plugin_id) > 0;
        shutting_down   = m_shutting_down.load(std::memory_order_acquire);
        if (exists && !invalid && !already_loaded && !load_in_progress && !shutting_down) {
            m_load_in_progress.insert(plugin_id);
            m_load_errors.erase(plugin_id);
            load_slot_claimed = true;
        }
    }
 
    if (already_loaded) {
        // An empty request means "restore the persisted capability state". Only an explicit
        // capability request may change an already-loaded capability, e.g. when resolving an
        // inactive-plugin reference. Runs outside m_mutex.
        for (const std::string& capability_name : capabilities_to_enable) {
            if (std::find(loaded_capability_names.begin(), loaded_capability_names.end(), capability_name) !=
                loaded_capability_names.end())
                set_capability_enabled({PluginCapabilityType::Unknown, capability_name, plugin_id}, true);
        }
 
        run_on_load_callbacks(plugin_id);
        return;
    }
 
    if (load_in_progress)
        return;
 
    if (shutting_down) {
        BOOST_LOG_TRIVIAL(info) << "Plugin load rejected — shutting down: " << plugin_id;
        run_on_load_callbacks(plugin_id);
        return;
    }
 
    if (!exists || invalid) {
        std::string message;
        if (invalid) {
            message = GUI::format(_u8L("Plugin is invalid: %1%"), plugin_id);
            if (!invalid_error.empty())
                message += " - " + invalid_error;
        } else {
            message = GUI::format(_u8L("Plugin not found: %1%"), plugin_id);
        }
 
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_load_errors[plugin_id] = message;
            BOOST_LOG_TRIVIAL(error) << message;
        }
 
        if (invalid)
            set_plugin_error(plugin_id, message);
 
        run_on_load_callbacks(plugin_id);
        return;
    }
 
    if (!load_slot_claimed)
        return;
 
    clear_plugin_error(plugin_id);
 
    std::thread([this, plugin_id, skip_deps, capabilities_to_enable]() {
        auto fail_unexpected = [this, &plugin_id](std::string message) {
            BOOST_LOG_TRIVIAL(error) << "[load_plugin] Unexpected worker failure plugin=" << plugin_id << " error=" << message;
            set_plugin_error(plugin_id, message);
            {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_load_errors[plugin_id] = std::move(message);
            }
        };
 
        try {
            load_plugin_impl(plugin_id, skip_deps, capabilities_to_enable);
        } catch (const std::exception& ex) {
            fail_unexpected(GUI::format(_u8L("Unexpected plugin load failure: %1%"), ex.what()));
        } catch (...) {
            fail_unexpected(_u8L("Unexpected plugin load failure"));
        }
 
        if (!m_shutting_down.load(std::memory_order_acquire))
            run_on_load_callbacks(plugin_id);
 
        // The worker owns its slot and releases it here, once it is done with Python for good —
        // including a load that was cancelled mid-flight, which is what keeps
        // wait_for_all_plugin_loads() blocking until the worker is really gone.
        release_load_slot(plugin_id);
    }).detach();
}

References _u8L, Slic3r::Plugin::capabilities, clear_plugin_error(), Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::GUI::format(), Slic3r::PluginDescriptor::is_invalid_package(), Slic3r::Plugin::is_loaded(), load_plugin_impl(), m_load_errors, m_load_in_progress, m_mutex, m_shutting_down, Slic3r::PluginDescriptor::normalized_error(), Slic3r::PluginDescriptor::plugin_key, release_load_slot(), run_on_load_callbacks(), set_capability_enabled(), set_plugin_error(), and Slic3r::Unknown.

Referenced by Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::resolve_inactive_plugins(), Slic3r::resolve_missing_plugins(), and Slic3r::GUI::PluginsDialog::toggle_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_plugin_impl()

void Slic3r::PluginManager::load_plugin_impl	(	const std::string &	plugin_key,
		bool	skip_deps,
		const std::vector< std::string > &	capabilities_to_enable )

private

{
    auto fail = [this, &plugin_key](std::string message) {
        BOOST_LOG_TRIVIAL(error) << "[load_plugin_impl] FAIL plugin=" << plugin_key << " error=" << message;
        set_plugin_error(plugin_key, message);
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_load_errors[plugin_key] = std::move(message);
        }
    };
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        fail(GUI::format(_u8L("Plugin manifest not found: %1%"), plugin_key));
        return;
    }
 
    // Reject a duplicate package or a capability-name collision BEFORE on_load() runs, so a
    // rejected load costs no on_load/on_unload cycle. Also the point at which a cancellation that
    // arrived while the module was importing is noticed.
    auto registry_precheck = [this, &plugin_key](const Plugin& candidate) -> std::string {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (is_plugin_load_cancelled_locked(plugin_key))
            return LOAD_CANCELLED;
        return check_registry_locked(plugin_key, candidate);
    };
 
    Plugin plugin;
    std::string error;
    bool registration_failed = false;
    if (!plugin_loader::load(descriptor, skip_deps, capabilities_to_enable, registry_precheck, plugin, error, &registration_failed)) {
        if (error == LOAD_CANCELLED)
            return; // cancelled: nothing materialized survives, and no error is recorded
        if (registration_failed)
            mark_plugin_install_state_disabled(plugin_key);
        fail(std::move(error));
        return;
    }
 
    for (const auto& cap : plugin.capabilities) {
        auto config = cap->get_default_config();
        if (config.empty())
            continue;
        const PluginCapabilityId id = cap->identity();
        if (m_config.has_config(id))
            continue;
 
        m_config.save_config({id, plugin.descriptor.installed_version, config});
    }
 
    bool committed = false;
    bool cancelled = false;
    std::string registry_error;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        cancelled = is_plugin_load_cancelled_locked(plugin_key);
        if (!cancelled) {
            registry_error = check_registry_locked(plugin_key, plugin);
            if (registry_error.empty()) {
                Plugin* entry = find_plugin_locked(plugin_key);
                if (entry == nullptr) {
                    registry_error = GUI::format(_u8L("Plugin manifest not found: %1%"), plugin_key);
                } else {
                    // Move everything via Plugin's own move assignment, but the package's
                    // descriptor (identity/metadata) belongs to the registry entry, not to the
                    // freshly-loaded `plugin` -- preserve it across the move.
                    PluginDescriptor entry_descriptor = std::move(entry->descriptor);
                    *entry                            = std::move(plugin);
                    entry->descriptor                 = std::move(entry_descriptor);
                    committed                         = true;
                }
            }
        }
    }
 
    if (!committed) {
        // Outside the lock: this runs on_unload() and DECREFs the module.
        plugin_loader::unload(plugin);
        if (!cancelled)
            fail(std::move(registry_error));
        return;
    }
 
    clear_plugin_error(plugin_key);
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_load_errors.erase(plugin_key);
    }
 
    BOOST_LOG_TRIVIAL(info) << "[load_plugin_impl] SUCCESS plugin=" << plugin_key;
}

References _u8L, Slic3r::Plugin::capabilities, check_registry_locked(), clear_plugin_error(), Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::GUI::format(), Slic3r::PluginDescriptor::installed_version, is_plugin_load_cancelled_locked(), Slic3r::plugin_loader::load(), m_config, m_load_errors, m_mutex, mark_plugin_install_state_disabled(), set_plugin_error(), try_get_plugin_descriptor(), and Slic3r::plugin_loader::unload().

Referenced by load_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_plugin_install_state_disabled()

void Slic3r::PluginManager::mark_plugin_install_state_disabled ( const std::string & plugin_key )

private

{
    std::lock_guard<std::mutex> state_lock(m_install_state_mutex);
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
        return;
 
    const boost::filesystem::path root(descriptor.plugin_root);
    PluginInstallState state;
    if (!read_install_state(root, state))
        seed_install_metadata(state, descriptor);
    state.enabled = false;
    if (!write_install_state(root, state))
        return;
 
    std::lock_guard<std::mutex> lock(m_mutex);
    if (Plugin* plugin = find_plugin_locked(plugin_key))
        plugin->descriptor.enabled = false;
}

References Slic3r::PluginInstallState::enabled, find_plugin_locked(), m_install_state_mutex, m_mutex, Slic3r::PluginDescriptor::plugin_root, Slic3r::read_install_state(), Slic3r::seed_install_metadata(), try_get_plugin_descriptor(), and Slic3r::write_install_state().

Referenced by load_plugin_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_discovered_plugins()

void Slic3r::PluginManager::merge_discovered_plugins	(	std::vector< PluginDescriptor >	discovered,
		bool	clear )

private

{
    std::vector<std::string> seen;
    seen.reserve(discovered.size());
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        for (PluginDescriptor& descriptor : discovered) {
            if (descriptor.plugin_key.empty())
                continue;
 
            if (std::find(seen.begin(), seen.end(), descriptor.plugin_key) != seen.end()) {
                const std::string duplicate_error = GUI::format(_u8L("Duplicate plugin key discovered: %1%"), descriptor.plugin_key);
                if (Plugin* existing = find_plugin_locked(descriptor.plugin_key)) {
                    existing->descriptor.set_error(duplicate_error);
                    BOOST_LOG_TRIVIAL(error) << duplicate_error << " (" << existing->descriptor.entry_path << ", "
                                             << descriptor.entry_path << ")";
                } else {
                    BOOST_LOG_TRIVIAL(error) << duplicate_error;
                }
                continue;
            }
 
            seen.push_back(descriptor.plugin_key);
            m_missing_plugin_keys.erase(descriptor.plugin_key);
 
            Plugin* existing = find_plugin_locked(descriptor.plugin_key);
            if (existing == nullptr) {
                Plugin plugin;
                plugin.descriptor = std::move(descriptor);
                m_plugins.push_back(std::move(plugin));
                continue;
            }
 
            // A manifest-only rescan has nothing to say about capabilities, so the live module and
            // instances are left alone.
            if (!descriptor.install_state_valid)
                descriptor.enabled = existing->descriptor.enabled;
            existing->descriptor = std::move(descriptor);
        }
 
        if (!clear)
            return;
    }
 
    // A package can be temporarily absent while an external side-loader replaces it. Keep the
    // descriptor and its persisted enable state until the user explicitly removes the missing
    // entry, or a later scan rediscovers it. In particular, do not unload here: the unload callback
    // would turn a transient filesystem gap into enabled=false in the sidecar.
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        for (const Plugin& plugin : m_plugins) {
            if (plugin.descriptor.has_local_package() &&
                std::find(seen.begin(), seen.end(), plugin.descriptor.plugin_key) == seen.end())
                m_missing_plugin_keys.insert(plugin.descriptor.plugin_key);
        }
    }
}

References _u8L, Slic3r::Plugin::descriptor, Slic3r::PluginDescriptor::enabled, find_plugin_locked(), Slic3r::GUI::format(), m_missing_plugin_keys, m_mutex, and m_plugins.

Referenced by run_discovery_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_plugin_load_state_changed()

void Slic3r::PluginManager::notify_plugin_load_state_changed ( bool changed )

private

{
    if (changed)
        m_load_cv.notify_all();
}

References m_load_cv.

Referenced by cancel_plugin_load(), release_load_slot(), and unload_plugin().

Here is the caller graph for this function:

◆ operator=()

PluginManager & Slic3r::PluginManager::operator= ( const PluginManager & )

privatedelete

References PluginManager().

Here is the call graph for this function:

◆ release_load_slot()

void Slic3r::PluginManager::release_load_slot ( const std::string & plugin_key )

private

{
    bool changed = false;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        changed = m_load_in_progress.erase(plugin_key) > 0;
        m_cancelled.erase(plugin_key);
    }
    notify_plugin_load_state_changed(changed);
}

References m_cancelled, m_load_in_progress, m_mutex, and notify_plugin_load_state_changed().

Referenced by load_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_missing_plugins()

void Slic3r::PluginManager::remove_missing_plugins ( const std::vector< std::string > & plugin_keys )

{
    const std::unordered_set<std::string> requested(plugin_keys.begin(), plugin_keys.end());
 
    // The predicate is evaluated only while m_mutex is held by unload_and_erase_if(). Checking the
    // current missing set here prevents a package that reappeared between the dialog and removal
    // from being erased.
    unload_and_erase_if([this, &requested](const Plugin& plugin) {
        return requested.count(plugin.descriptor.plugin_key) != 0 &&
               m_missing_plugin_keys.count(plugin.descriptor.plugin_key) != 0;
    });
 
    std::lock_guard<std::mutex> lock(m_mutex);
    for (const std::string& plugin_key : requested)
        m_missing_plugin_keys.erase(plugin_key);
}

References Slic3r::Plugin::descriptor, m_missing_plugin_keys, m_mutex, Slic3r::PluginDescriptor::plugin_key, and unload_and_erase_if().

Referenced by Slic3r::GUI::PluginsDialog::prompt_for_missing_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rescan_plugins()

void Slic3r::PluginManager::rescan_plugins ( )

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Rescanning plugins...";
 
    std::string wait_error;
    wait_for_discovery(std::chrono::milliseconds::max(), wait_error);
 
    discover_plugins(/*async=*/false, /*clear=*/true);
}

References discover_plugins(), and wait_for_discovery().

Referenced by Slic3r::GUI::refresh_plugin_metadata_blocking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ revoke_plugin_permissions()

void Slic3r::PluginManager::revoke_plugin_permissions ( const std::string & plugin_key )

private

{
    std::lock_guard<std::mutex> state_lock(m_install_state_mutex);
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
        return;
 
    const boost::filesystem::path root(descriptor.plugin_root);
    PluginInstallState state;
    if (!read_install_state(root, state)) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Failed to read install state for " << plugin_key;
        return;
    }
 
    state.permissions = {};
    if (!write_install_state(root, state))
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Failed to revoke permissions for " << plugin_key;
}

References m_install_state_mutex, Slic3r::PluginInstallState::permissions, Slic3r::PluginDescriptor::plugin_root, Slic3r::read_install_state(), try_get_plugin_descriptor(), and Slic3r::write_install_state().

Referenced by install_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_discovery()

void Slic3r::PluginManager::run_discovery	(	bool	async,
		bool	clear )

private

{
    auto task = [this, clear]() { run_discovery_task(clear); };
 
    if (async)
        std::thread(std::move(task)).detach();
    else
        task();
}

References run_discovery_task().

Referenced by discover_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_discovery_task()

void Slic3r::PluginManager::run_discovery_task ( bool clear )

private

{
    std::string error;
 
    try {
        std::string cloud_user_id;
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            cloud_user_id = m_cloud_user_id;
        }
 
        const std::vector<std::string> dirs      = get_plugin_directories(cloud_user_id);
        std::vector<PluginDescriptor> discovered = discover_plugin_packages(dirs, error);
        merge_discovered_plugins(std::move(discovered), clear);
    } catch (const std::exception& ex) {
        error = std::string("Plugin discovery failed: ") + ex.what();
        BOOST_LOG_TRIVIAL(error) << error;
    } catch (...) {
        error = "Plugin discovery failed: unknown error";
        BOOST_LOG_TRIVIAL(error) << error;
    }
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_discovery_error       = std::move(error);
        m_discovery_complete    = true;
        m_discovery_in_progress = false;
    }
    m_discovery_cv.notify_all();
}

References Slic3r::discover_plugin_packages(), Slic3r::get_plugin_directories(), m_cloud_user_id, m_discovery_complete, m_discovery_cv, m_discovery_error, m_discovery_in_progress, m_mutex, and merge_discovered_plugins().

Referenced by run_discovery().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_on_capability_load_callbacks()

void Slic3r::PluginManager::run_on_capability_load_callbacks ( const PluginCapabilityId & id )

private

{
    auto work = [callbacks = copy_capability_callbacks(CallbackType::Load), id] {
        for (auto& fn : callbacks) {
            try {
                fn(id);
            } catch (const std::exception& ex) {
                BOOST_LOG_TRIVIAL(error) << "Plugin capability load callback failed for " << id.plugin_key << "/" << id.name << ": "
                                         << ex.what();
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "Plugin capability load callback failed for " << id.plugin_key << "/" << id.name;
            }
        }
    };
    if (wxTheApp == nullptr || wxIsMainThread())
        work();
    else
        GUI::wxGetApp().CallAfter(std::move(work));
}

References copy_capability_callbacks(), and Load.

Referenced by keep_installed_plugin_as_local(), and set_capability_enabled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_on_capability_unload_callbacks()

void Slic3r::PluginManager::run_on_capability_unload_callbacks ( const PluginCapabilityId & id )

private

{
    auto work = [callbacks = copy_capability_callbacks(CallbackType::Unload), id] {
        for (auto& fn : callbacks) {
            try {
                fn(id);
            } catch (const std::exception& ex) {
                BOOST_LOG_TRIVIAL(error) << "Plugin capability unload callback failed for " << id.plugin_key << "/" << id.name << ": "
                                         << ex.what();
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "Plugin capability unload callback failed for " << id.plugin_key << "/" << id.name;
            }
        }
    };
    if (wxTheApp == nullptr || wxIsMainThread())
        work();
    else
        GUI::wxGetApp().CallAfter(std::move(work));
}

References copy_capability_callbacks(), and Unload.

Referenced by keep_installed_plugin_as_local(), and set_capability_enabled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_on_load_callbacks()

void Slic3r::PluginManager::run_on_load_callbacks ( const std::string & plugin_key )

private

{
    auto work = [callbacks = copy_callbacks(CallbackType::Load), plugin_key] {
        for (auto& fn : callbacks) {
            try {
                fn(plugin_key);
            } catch (const std::exception& ex) {
                BOOST_LOG_TRIVIAL(error) << "Plugin load completion callback failed for " << plugin_key << ": " << ex.what();
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "Plugin load completion callback failed for " << plugin_key;
            }
        }
    };
    if (wxTheApp == nullptr || wxIsMainThread())
        work();
    else
        GUI::wxGetApp().CallAfter(std::move(work));
}

References copy_callbacks(), and Load.

Referenced by load_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_on_unload_callbacks()

void Slic3r::PluginManager::run_on_unload_callbacks ( const std::string & plugin_key )

private

{
    auto work = [callbacks = copy_callbacks(CallbackType::Unload), plugin_key] {
        for (auto& fn : callbacks) {
            try {
                fn(plugin_key);
            } catch (const std::exception& ex) {
                BOOST_LOG_TRIVIAL(error) << "Plugin unload completion callback failed for " << plugin_key << ": " << ex.what();
            } catch (...) {
                BOOST_LOG_TRIVIAL(error) << "Plugin unload completion callback failed for " << plugin_key << ": unknown error";
            }
        }
    };
    if (wxTheApp == nullptr || wxIsMainThread())
        work();
    else
        GUI::wxGetApp().CallAfter(std::move(work));
}

References copy_callbacks(), and Unload.

Referenced by unload_all_plugins(), and unload_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_script_capability()

ExecutionResult Slic3r::PluginManager::run_script_capability	(	const std::string &	plugin_key,
		const std::string &	capability_name,
		std::string &	error )

{
    ExecutionResult result;
    std::mutex              mutex;
    std::condition_variable cv;
    bool                    done = false;
 
    ScriptLaunchResult launch = launch_script_capability(
        plugin_key, capability_name, [&](const ScriptCompletion& completion) {
            std::lock_guard<std::mutex> lock(mutex);
            result = completion.result;
            // A cancel_plugin() cancellation is expected termination, not an error to report.
            error  = completion.cancelled ? std::string() : completion.error;
            done   = true;
            cv.notify_all();
        });
 
    if (launch.launched_async) {
        // Async run: the completion is delivered on the GUI thread. When this call is itself on
        // the GUI thread it must pump the event loop, or the completion can never be delivered.
        std::unique_lock<std::mutex> lock(mutex);
        if (wxTheApp != nullptr && wxIsMainThread()) {
            while (!done) {
                cv.wait_for(lock, std::chrono::milliseconds(10));
                lock.unlock();
                wxYield();
                lock.lock();
            }
        } else {
            cv.wait(lock, [&] { return done; });
        }
    } else {
        result = launch.outcome.result;
        error  = launch.outcome.error;
    }
 
    return result;
}

References Slic3r::ScriptCompletion::cancelled, Slic3r::ScriptCompletion::error, launch_script_capability(), Slic3r::PluginManager::ScriptLaunchResult::launched_async, Slic3r::PluginManager::ScriptLaunchResult::outcome, and Slic3r::ScriptCompletion::result.

Here is the call graph for this function:

◆ set_capability_enabled()

void Slic3r::PluginManager::set_capability_enabled	(	const PluginCapabilityId &	id,
		bool	enabled )

{
    PluginCapabilityId changed;
    bool did_change = false;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        Plugin* plugin = find_plugin_locked(id.plugin_key);
        if (plugin == nullptr || !plugin->is_loaded())
            return;
 
        for (const auto& capability : plugin->capabilities) {
            if (!capability || capability->name() != id.name ||
                (id.type != PluginCapabilityType::Unknown && capability->type() != id.type) ||
                capability->is_enabled() == enabled)
                continue;
 
            capability->set_enabled(enabled);
            changed    = capability->identity();
            did_change = true;
            break;
        }
    }
 
    if (!did_change)
        return;
 
    write_loaded_plugin_install_state(id.plugin_key);
 
    if (enabled)
        run_on_capability_load_callbacks(changed);
    else
        run_on_capability_unload_callbacks(changed);
}

References Slic3r::Plugin::capabilities, find_plugin_locked(), Slic3r::Plugin::is_loaded(), m_mutex, run_on_capability_load_callbacks(), run_on_capability_unload_callbacks(), Slic3r::Unknown, and write_loaded_plugin_install_state().

Referenced by load_plugin(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), and Slic3r::GUI::PluginsDialog::toggle_plugin_capability().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_cloud_agent()

void Slic3r::PluginManager::set_cloud_agent ( std::shared_ptr< OrcaCloudServiceAgent > agent )

inline

205{ m_cloud_service.set_cloud_agent(std::move(agent)); }

References m_cloud_service.

Referenced by Slic3r::GUI::GUI_App::on_init_inner().

Here is the caller graph for this function:

◆ set_cloud_user()

void Slic3r::PluginManager::set_cloud_user ( const std::string & user_id )

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_cloud_user_id = user_id;
}

References m_cloud_user_id, and m_mutex.

Referenced by download_and_install_cloud_plugin(), Slic3r::GUI::GUI_App::on_init_inner(), and Slic3r::GUI::GUI_App::request_user_logout().

Here is the caller graph for this function:

◆ set_plugin_error()

bool Slic3r::PluginManager::set_plugin_error	(	const std::string &	plugin_key,
		std::string	error )

{
    std::string wait_error;
    if (!wait_for_discovery(std::chrono::milliseconds::max(), wait_error))
        return false;
 
    std::lock_guard<std::mutex> lock(m_mutex);
    Plugin* plugin = find_plugin_locked(plugin_key);
    if (plugin == nullptr)
        return false;
 
    plugin->descriptor.set_error(std::move(error));
    return true;
}

References Slic3r::Plugin::descriptor, find_plugin_locked(), m_mutex, Slic3r::PluginDescriptor::set_error(), and wait_for_discovery().

Referenced by delete_and_unsubscribe_cloud_plugin(), delete_plugin(), download_and_install_cloud_plugin(), Slic3r::GUI::PluginsDialog::install_cloud_plugin(), install_plugin(), launch_script_capability(), load_plugin(), load_plugin_impl(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), Slic3r::GUI::PluginsDialog::run_script_plugin_capability(), Slic3r::GUI::PluginsDialog::toggle_plugin(), unsubscribe_cloud_plugin(), and update_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_shutting_down()

void Slic3r::PluginManager::set_shutting_down ( )

148{ m_shutting_down.store(true, std::memory_order_release); }

References m_shutting_down.

Referenced by Slic3r::GUI::GUI_App::shutdown(), and shutdown().

Here is the caller graph for this function:

◆ shutdown()

void Slic3r::PluginManager::shutdown ( )

{
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        const bool idle_and_empty = m_load_in_progress.empty() && std::none_of(m_plugins.begin(), m_plugins.end(),
                                                                               [](const Plugin& plugin) { return plugin.is_loaded(); });
        if (!m_initialized && !m_discovery_in_progress && idle_and_empty)
            return;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": PluginManager shutdown enter";
 
    // Detach the libslic3r hooks first so nothing dispatches into Python while (or after) plugins
    // unload. The lifecycle-event hook also drains callbacks already in progress before returning;
    // the remaining hook seams retain their existing shutdown requirements.
    plugin_hooks::uninstall();
 
    // Reject new plugin loads before we drain.
    set_shutting_down();
 
    std::string wait_error;
    if (!wait_for_discovery(std::chrono::milliseconds::max(), wait_error) && !wait_error.empty())
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Plugin discovery did not finish cleanly during shutdown: " << wait_error;
 
    // Wait for any in-progress plugin loads. Cancelled loads keep their slot until their worker
    // has actually unwound, so this cannot return while one is still executing Python.
    wait_for_all_plugin_loads();
 
    unload_all_plugins();
    PythonPluginBridge::instance().clear_pending_captures();
 
    // Every async Script run has been drained by unload_all_plugins above; wait for every
    // invocation worker before the interpreter is allowed to finalize.
    ScriptAsyncRuntime::instance().shutdown();
 
    // Every config write already goes to disk as it happens (store_capability_config), so this
    // only catches an in-memory-only mutation. Note we flush rather than clear: unloading the
    // plugins above must never discard their stored config.
    if (m_config.dirty())
        m_config.save();
 
    // Drop the lifecycle subscriptions taken out during initialize(). Without this a second
    // initialize() in the same process re-subscribes the same callbacks on top of the old ones,
    // and every load would then write the install-state sidecar once per duplicate.
    clear_callbacks();
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_initialized = false;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": PluginManager shutdown exit";
}

References clear_callbacks(), Slic3r::PythonPluginBridge::clear_pending_captures(), Slic3r::PythonPluginBridge::instance(), Slic3r::ScriptAsyncRuntime::instance(), m_config, m_discovery_in_progress, m_initialized, m_load_in_progress, m_mutex, m_plugins, set_shutting_down(), Slic3r::ScriptAsyncRuntime::shutdown(), Slic3r::plugin_hooks::uninstall(), unload_all_plugins(), wait_for_all_plugin_loads(), and wait_for_discovery().

Referenced by Slic3r::GUI::GUI_App::~GUI_App(), ~PluginManager(), and Slic3r::GUI::GUI_App::on_init_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subscribe_and_install_cloud_plugin()

bool Slic3r::PluginManager::subscribe_and_install_cloud_plugin	(	const std::string &	plugin_key,
		std::string &	error )

{
    error.clear();
 
    const std::string plugin_uuid = is_uuid(plugin_key) ? plugin_key : std::string{};
    if (plugin_uuid.empty()) {
        error = _u8L("Cloud plugin key is missing UUID.");
        return false;
    }
    if (!m_cloud_service.can_fetch_cloud_plugins()) {
        error = _u8L("Sign in to OrcaCloud to install this plugin.");
        return false;
    }
 
    PluginDescriptor descriptor;
    bool found = try_get_plugin_descriptor(plugin_key, descriptor) && descriptor.is_cloud_plugin();
    if (!found) {
        fetch_plugins_from_cloud();
        found = try_get_plugin_descriptor(plugin_key, descriptor) && descriptor.is_cloud_plugin();
    }
 
    if (!found) {
        if (!m_cloud_service.request_cloud_subscribe(plugin_uuid, error))
            return false;
 
        fetch_plugins_from_cloud();
        found = try_get_plugin_descriptor(plugin_key, descriptor) && descriptor.is_cloud_plugin();
        if (!found) {
            error = _u8L("Subscribed cloud plugin was not returned by OrcaCloud.");
            return false;
        }
    }
 
    if (descriptor.has_local_package())
        return true;
 
    return download_and_install_cloud_plugin(descriptor.plugin_key, descriptor.version, error);
}

References _u8L, download_and_install_cloud_plugin(), fetch_plugins_from_cloud(), Slic3r::PluginDescriptor::has_local_package(), Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::is_uuid(), m_cloud_service, Slic3r::PluginDescriptor::plugin_key, try_get_plugin_descriptor(), and Slic3r::PluginDescriptor::version.

Referenced by Slic3r::resolve_missing_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subscribe_on_capability_load_callback()

void Slic3r::PluginManager::subscribe_on_capability_load_callback ( CapabilityLifecycleFn fn )

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_capability_callbacks[CallbackType::Load].push_back(std::move(fn));
}

References Load, m_capability_callbacks, and m_mutex.

Referenced by Slic3r::GUI::ActionRegistry::init(), and Slic3r::GUI::GUI_App::init_plugin_gui_wiring().

Here is the caller graph for this function:

◆ subscribe_on_capability_unload_callback()

void Slic3r::PluginManager::subscribe_on_capability_unload_callback ( CapabilityLifecycleFn fn )

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_capability_callbacks[CallbackType::Unload].push_back(std::move(fn));
}

References m_capability_callbacks, m_mutex, and Unload.

Referenced by Slic3r::GUI::ActionRegistry::init(), and Slic3r::GUI::GUI_App::init_plugin_gui_wiring().

Here is the caller graph for this function:

◆ subscribe_on_load_callback()

void Slic3r::PluginManager::subscribe_on_load_callback ( PluginLifecycleCompleteFn fn )

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_callbacks[CallbackType::Load].push_back(std::move(fn));
}

References Load, m_callbacks, and m_mutex.

Referenced by Slic3r::GUI::ActionRegistry::init(), Slic3r::GUI::GUI_App::init_plugin_gui_wiring(), and initialize().

Here is the caller graph for this function:

◆ subscribe_on_unload_callback()

void Slic3r::PluginManager::subscribe_on_unload_callback ( PluginLifecycleCompleteFn fn )

{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_callbacks[CallbackType::Unload].push_back(std::move(fn));
}

References m_callbacks, m_mutex, and Unload.

Referenced by Slic3r::GUI::ActionRegistry::init(), Slic3r::GUI::GUI_App::init_plugin_gui_wiring(), and initialize().

Here is the caller graph for this function:

◆ try_get_plugin_descriptor()

bool Slic3r::PluginManager::try_get_plugin_descriptor	(	const std::string &	plugin_key,
		PluginDescriptor &	out ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    const Plugin* plugin = find_plugin_locked(plugin_key);
    if (plugin == nullptr)
        return false;
 
    out = plugin->descriptor;
    return true;
}

References Slic3r::Plugin::descriptor, find_plugin_locked(), and m_mutex.

Referenced by delete_and_unsubscribe_cloud_plugin(), delete_plugin(), download_and_install_cloud_plugin(), Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::find_loaded_source_name(), Slic3r::GUI::PluginsDialog::get_descriptor(), get_install_state(), get_storage_dir(), initialize(), load_plugin_impl(), mark_plugin_install_state_disabled(), Slic3r::GUI::OptionsGroup::pick_plugin(), Slic3r::refresh_missing_plugins(), Slic3r::NetworkAgentFactory::register_python_printer_agent(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::resolve_inactive_plugins(), Slic3r::resolve_missing_plugins(), revoke_plugin_permissions(), subscribe_and_install_cloud_plugin(), unsubscribe_cloud_plugin(), and update_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_get_plugin_descriptor_for_capability()

bool Slic3r::PluginManager::try_get_plugin_descriptor_for_capability	(	const std::string &	capability_name,
		PluginCapabilityType	type,
		PluginDescriptor &	out ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    for (const Plugin& plugin : m_plugins) {
        for (const auto& capability : plugin.capabilities) {
            if (!capability || capability->name() != capability_name)
                continue;
            if (type != PluginCapabilityType::Unknown && capability->type() != type)
                continue;
            out = plugin.descriptor;
            return true;
        }
    }
 
    return false;
}

References m_mutex, m_plugins, and Slic3r::Unknown.

Referenced by Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_capability_resolver().

Here is the caller graph for this function:

◆ try_get_valid_plugin_descriptor()

bool Slic3r::PluginManager::try_get_valid_plugin_descriptor	(	const std::string &	plugin_key,
		PluginDescriptor &	out ) const

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    const Plugin* plugin = find_plugin_locked(plugin_key);
    if (plugin == nullptr || plugin->descriptor.is_invalid_package())
        return false;
 
    out = plugin->descriptor;
    return true;
}

References Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::PluginDescriptor::is_invalid_package(), and m_mutex.

Referenced by Slic3r::GUI::PluginsDialog::get_descriptor(), and Slic3r::GUI::PluginsDialog::toggle_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_all_plugins()

void Slic3r::PluginManager::unload_all_plugins ( )

{
    std::vector<Plugin> removed;
    std::vector<std::string> removed_keys;
    std::vector<std::shared_ptr<PluginCapabilityInterface>> capabilities;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        for (Plugin& plugin : m_plugins) {
            if (!plugin.is_loaded())
                continue;
 
            // Take the live parts out via Plugin's own move; the descriptor stays behind, as in
            // unload_plugin() above.
            PluginDescriptor kept_descriptor = std::move(plugin.descriptor);
            Plugin           taken           = std::move(plugin);
            plugin.descriptor                = std::move(kept_descriptor);
            removed.push_back(std::move(taken));
            removed_keys.push_back(plugin.descriptor.plugin_key);
            capabilities.insert(capabilities.end(), removed.back().capabilities.begin(), removed.back().capabilities.end());
        }
    }
 
    // Bulk shutdown intentionally skips the normal unload notification path, but resources owned
    // by GUI subscribers still need to be torn down before the interpreter is finalized.
    for (const std::string& key : removed_keys)
        run_on_unload_callbacks(key);
 
    // Broadcast cancellation to every plugin before waiting. This keeps bulk unload from
    // starving a later plugin while an earlier plugin uses the full cancellation grace period.
    cancel_and_wait_for_capabilities(capabilities);
 
    for (Plugin& plugin : removed)
        plugin_loader::unload(plugin);
}

References cancel_and_wait_for_capabilities(), m_mutex, m_plugins, run_on_unload_callbacks(), and Slic3r::plugin_loader::unload().

Referenced by shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_and_erase_if()

void Slic3r::PluginManager::unload_and_erase_if	(	const std::function< bool(const Plugin &)> &	should_remove,
		const std::function< void()> &	after_erase_locked = {} )

private

{
    for (;;) {
        std::vector<std::string> unload_keys;
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            for (const Plugin& plugin : m_plugins) {
                if (should_remove(plugin) && plugin.is_loaded())
                    unload_keys.push_back(plugin.descriptor.plugin_key);
            }
        }
 
        if (unload_keys.empty()) {
            std::lock_guard<std::mutex> lock(m_mutex);
            // Keep the check and erase in one critical section so a concurrent load cannot make a
            // live entry reach vector compaction and move-assignment.
            bool loaded_entry_found = false;
            for (const Plugin& plugin : m_plugins) {
                if (should_remove(plugin) && plugin.is_loaded()) {
                    loaded_entry_found = true;
                    break;
                }
            }
            if (loaded_entry_found)
                continue;
 
            m_plugins.erase(std::remove_if(m_plugins.begin(), m_plugins.end(), should_remove), m_plugins.end());
            if (after_erase_locked)
                after_erase_locked();
            break;
        }
        for (const std::string& key : unload_keys)
            unload_plugin(key);
    }
}

References m_mutex, m_plugins, and unload_plugin().

Referenced by clear_cloud_plugin_metadata(), and remove_missing_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_cloud_plugins()

void Slic3r::PluginManager::unload_cloud_plugins ( )

{
    std::vector<std::string> keys;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        for (const Plugin& plugin : m_plugins) {
            if (plugin.is_loaded() && plugin.descriptor.is_cloud_plugin())
                keys.push_back(plugin.descriptor.plugin_key);
        }
    }
 
    // Release m_mutex before unloading: unload_plugin() re-acquires it and runs plugin teardown
    // plus unload callbacks, which can re-enter the manager.
    for (const std::string& key : keys)
        unload_plugin(key);
}

References m_mutex, m_plugins, and unload_plugin().

Referenced by Slic3r::GUI::GUI_App::request_user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_plugin()

bool Slic3r::PluginManager::unload_plugin ( const std::string & plugin_key )

{
    auto notify_unload_complete = [this, &plugin_key]() {
        if (!m_shutting_down.load(std::memory_order_acquire))
            run_on_unload_callbacks(plugin_key);
    };
 
    Plugin removed;
    bool cancelled = false;
    bool found     = false;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        // Cancel any in-progress load for this plugin so its worker discards the result.
        cancelled = cancel_plugin_load_locked(plugin_key);
 
        Plugin* plugin = find_plugin_locked(plugin_key);
        if (plugin != nullptr && plugin->is_loaded()) {
            found = true;
 
            // Take the live parts out of the entry via Plugin's own move assignment; the
            // descriptor stays behind, so the package remains discovered. Everything
            // capability-shaped is discarded with the capabilities — the user's enable choices
            // live on in the .install_state.json sidecar.
            PluginDescriptor kept_descriptor = std::move(plugin->descriptor);
            removed                          = std::move(*plugin);
            plugin->descriptor               = std::move(kept_descriptor);
        }
    }
 
    if (!found) {
        notify_plugin_load_state_changed(cancelled);
        return true;
    }
 
    notify_unload_complete();
 
    cancel_and_wait_for_capabilities(removed.capabilities);
 
    notify_plugin_load_state_changed(cancelled);
 
    // Teardown runs outside m_mutex: it calls into Python and must not hold the registry lock.
    plugin_loader::unload(removed);
 
    // The .install_state.json sidecar is flipped to enabled=false by the on-unload callback
    // (skipped during shutdown), so the auto-load list survives app exit.
    BOOST_LOG_TRIVIAL(info) << "Unloaded plugin: " << plugin_key;
 
    return true;
}

References cancel_and_wait_for_capabilities(), cancel_plugin_load_locked(), Slic3r::Plugin::capabilities, Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::Plugin::is_loaded(), m_mutex, m_shutting_down, notify_plugin_load_state_changed(), run_on_unload_callbacks(), and Slic3r::plugin_loader::unload().

Referenced by delete_and_unsubscribe_cloud_plugin(), delete_installed_plugin_package(), install_plugin(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::GUI::PluginsDialog::run_script_plugin_capability(), Slic3r::GUI::PluginsDialog::toggle_plugin(), unload_and_erase_if(), unload_cloud_plugins(), and update_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unsubscribe_cloud_plugin()

bool Slic3r::PluginManager::unsubscribe_cloud_plugin	(	const std::string &	plugin_key,
		std::string &	error )

{
    if (!wait_for_discovery(std::chrono::milliseconds::max(), error))
        return false;
 
    error.clear();
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        error = GUI::format(_u8L("Plugin not found: %1%"), plugin_key);
        return false;
    }
 
    if (!descriptor.is_cloud_plugin()) {
        error = _u8L("Only cloud plugins can be unsubscribed.");
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    if (descriptor.cloud && descriptor.cloud->is_mine) {
        error = _u8L("Cannot unsubscribe your own plugins.");
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    if (!m_cloud_service.request_cloud_unsubscribe(descriptor, error)) {
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    return finalize_cloud_plugin_removal(descriptor, true, error);
}

References _u8L, Slic3r::PluginDescriptor::cloud, finalize_cloud_plugin_removal(), Slic3r::GUI::format(), Slic3r::PluginDescriptor::is_cloud_plugin(), m_cloud_service, set_plugin_error(), try_get_plugin_descriptor(), and wait_for_discovery().

Here is the call graph for this function:

◆ update_cloud_metadata()

void Slic3r::PluginManager::update_cloud_metadata ( const std::vector< PluginDescriptor > & cloud_list )

{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    // Collected and appended after the scan: push_back into m_plugins would invalidate the
    // pointers the loop is holding.
    std::vector<PluginDescriptor> new_entries;
 
    for (const PluginDescriptor& cloud_entry : cloud_list) {
        const std::string cloud_uuid = cloud_entry.cloud_uuid();
        const std::string cloud_key  = cloud_entry.plugin_key;
        if (cloud_uuid.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "Skipping cloud plugin record without UUID";
            continue;
        }
 
        const auto matches_cloud_descriptor = [&cloud_key, &cloud_uuid](const PluginDescriptor& entry) {
            if (!cloud_key.empty() && entry.plugin_key == cloud_key)
                return true;
            return entry.is_cloud_plugin() && entry.cloud_uuid() == cloud_uuid;
        };
 
        const auto existing = std::find_if(m_plugins.begin(), m_plugins.end(), [&matches_cloud_descriptor](const Plugin& plugin) {
            return matches_cloud_descriptor(plugin.descriptor);
        });
 
        if (existing == m_plugins.end()) {
            PluginDescriptor normalized_entry = cloud_entry;
            if (normalized_entry.plugin_key.empty())
                normalized_entry.plugin_key = cloud_uuid;
            if (!normalized_entry.cloud.has_value())
                normalized_entry.cloud = CloudPluginState{cloud_uuid, false, false, false};
            else if (normalized_entry.cloud->uuid.empty())
                normalized_entry.cloud->uuid = cloud_uuid;
            new_entries.push_back(std::move(normalized_entry));
            continue;
        }
 
        PluginDescriptor& entry = existing->descriptor;
 
        const PluginDescriptor local_entry  = entry;
        const std::string installed_version = entry.installed_version;
        const std::string latest_version    = cloud_entry.latest_available_version();
        const std::string local_plugin_root = entry.plugin_root;
        const std::string local_entry_path  = entry.entry_path;
        const bool local_metadata_ok        = entry.is_metadata_valid();
        const bool has_local_package        = entry.has_local_package();
        const std::string previous_error    = entry.error;
        // The cloud does not know about the local auto-load flag, which comes from the sidecar.
        const bool enabled = entry.enabled;
 
        entry             = cloud_entry;
        entry.plugin_root = local_plugin_root;
        entry.entry_path  = local_entry_path;
        if (has_local_package)
            apply_plugin_metadata_fallbacks(entry, local_entry);
        if (entry.plugin_key.empty())
            entry.plugin_key = cloud_uuid;
        entry.metadata_valid = has_local_package ? local_metadata_ok : cloud_entry.metadata_valid;
        entry.error          = previous_error;
        entry.enabled        = enabled;
        if (!entry.cloud.has_value())
            entry.cloud = CloudPluginState{cloud_uuid, has_local_package, false, false};
        else if (entry.cloud->uuid.empty())
            entry.cloud->uuid = cloud_uuid;
 
        entry.cloud->installed = has_local_package;
        // The installed version is the source of truth read back from the install-state sidecar
        // (the version fetched from the cloud at install time), not the local manifest/PEP723
        // header. The header may be stale — the cloud can bump the version without the header
        // changing — which would otherwise make an already-updated plugin appear perpetually out
        // of date.
        entry.installed_version       = has_local_package ? installed_version : std::string{};
        entry.cloud->update_available = has_local_package && local_metadata_ok && !installed_version.empty() && !latest_version.empty() &&
                                        is_cloud_version_newer(latest_version, installed_version);
        if (entry.normalized_error() == CLOUD_PLUGIN_NOT_FOUND_ERROR)
            entry.clear_error();
    }
 
    for (PluginDescriptor& descriptor : new_entries) {
        Plugin plugin;
        plugin.descriptor = std::move(descriptor);
        m_plugins.push_back(std::move(plugin));
    }
}

Referenced by Slic3r::GUI::PluginsDialog::delete_local_plugin(), fetch_plugins_from_cloud(), Slic3r::GUI::refresh_plugin_metadata_blocking(), and Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_cloud_plugin()

bool Slic3r::PluginManager::update_cloud_plugin	(	const std::string &	plugin_key,
		std::string &	error,
		std::string	version = "" )

{
    error.clear();
 
    PluginDescriptor descriptor;
    if (!try_get_plugin_descriptor(plugin_key, descriptor)) {
        error = GUI::format(_u8L("Plugin not found: %1%"), plugin_key);
        return false;
    }
 
    if (!descriptor.is_cloud_plugin()) {
        error = _u8L("Only cloud plugins can be updated.");
        set_plugin_error(plugin_key, error);
        return false;
    }
 
    // An empty version means "update the current plugin". If there is no update available, the
    // intention is unclear.
    if (version.empty()) {
        if (descriptor.cloud->update_available) {
            version = descriptor.latest_available_version();
        } else {
            error = _u8L("No update is available for this plugin.");
            set_plugin_error(plugin_key, error);
            return false;
        }
    }
 
    clear_plugin_error(plugin_key);
 
    if (descriptor.has_local_package()) {
        boost::filesystem::path resolved_root;
        bool resolved_allowed_plugin_root = false;
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            resolved_allowed_plugin_root = resolve_allowed_plugin_root(descriptor, get_plugin_directories(m_cloud_user_id),
                                                                       _u8L("Refusing to delete a plugin outside the known plugin directories."),
                                                                       resolved_root, error);
        }
 
        if (!resolved_allowed_plugin_root) {
            set_plugin_error(plugin_key, error);
            return false;
        }
 
        unload_plugin(plugin_key);
 
        if (!delete_plugin_root(resolved_root, plugin_key, error)) {
            set_plugin_error(plugin_key, error);
            return false;
        }
    }
 
    if (!download_and_install_cloud_plugin(plugin_key, version, error)) {
        set_plugin_error(plugin_key, error);
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": " << error;
        return false;
    }
 
    clear_plugin_error(plugin_key);
 
    return true;
}

References _u8L, clear_plugin_error(), Slic3r::PluginDescriptor::cloud, Slic3r::delete_plugin_root(), download_and_install_cloud_plugin(), Slic3r::GUI::format(), Slic3r::get_plugin_directories(), Slic3r::PluginDescriptor::has_local_package(), Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::PluginDescriptor::latest_available_version(), m_cloud_user_id, m_mutex, Slic3r::resolve_allowed_plugin_root(), set_plugin_error(), try_get_plugin_descriptor(), and unload_plugin().

Referenced by Slic3r::GUI::PluginsDialog::update_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wait_for_all_plugin_loads() [1/2]

void Slic3r::PluginManager::wait_for_all_plugin_loads ( ) const

{
    std::unique_lock<std::mutex> lock(m_mutex);
    m_load_cv.wait(lock, [this]() { return m_load_in_progress.empty(); });
}

References m_load_cv, m_load_in_progress, and m_mutex.

Referenced by Slic3r::execute_capabilities_from_refs(), and shutdown().

Here is the caller graph for this function:

◆ wait_for_all_plugin_loads() [2/2]

bool Slic3r::PluginManager::wait_for_all_plugin_loads ( std::chrono::milliseconds timeout ) const

{
    std::unique_lock<std::mutex> lock(m_mutex);
    return m_load_cv.wait_for(lock, timeout, [this]() { return m_load_in_progress.empty(); });
}

References m_load_cv, m_load_in_progress, and m_mutex.

◆ wait_for_discovery()

bool Slic3r::PluginManager::wait_for_discovery	(	std::chrono::milliseconds	timeout,
		std::string &	error ) const

{
    std::unique_lock<std::mutex> lock(m_mutex);
    if (!m_discovery_in_progress)
        return true;
 
    const auto done = [this]() { return !m_discovery_in_progress; };
 
    if (timeout == std::chrono::milliseconds::max()) {
        m_discovery_cv.wait(lock, done);
        return true;
    }
 
    if (!m_discovery_cv.wait_for(lock, timeout, done)) {
        error = "Plugin discovery is still running";
        return false;
    }
 
    return true;
}

References m_discovery_cv, m_discovery_in_progress, and m_mutex.

Referenced by clear_plugin_error(), delete_and_unsubscribe_cloud_plugin(), delete_plugin(), install_plugin(), rescan_plugins(), set_plugin_error(), shutdown(), and unsubscribe_cloud_plugin().

Here is the caller graph for this function:

◆ wait_for_plugin_load()

bool Slic3r::PluginManager::wait_for_plugin_load	(	const std::string &	plugin_key,
		std::chrono::milliseconds	timeout,
		std::string &	error ) const

{
    std::unique_lock<std::mutex> lock(m_mutex);
 
    const auto done = [this, &plugin_key]() { return m_load_in_progress.count(plugin_key) == 0; };
 
    if (timeout == std::chrono::milliseconds::max()) {
        m_load_cv.wait(lock, done);
    } else if (!m_load_cv.wait_for(lock, timeout, done)) {
        error = _u8L("Plugin load is still in progress");
        return false;
    }
 
    const auto it = m_load_errors.find(plugin_key);
    if (it != m_load_errors.end()) {
        error = it->second;
        return false;
    }
 
    return true;
}

References _u8L, m_load_cv, m_load_errors, m_load_in_progress, and m_mutex.

Referenced by Slic3r::GUI::PluginsDialog::reinstall_cloud_plugin(), Slic3r::GUI::PluginsDialog::reload_local_plugin(), Slic3r::resolve_inactive_plugins(), and Slic3r::resolve_missing_plugins().

Here is the caller graph for this function:

◆ write_loaded_plugin_install_state()

void Slic3r::PluginManager::write_loaded_plugin_install_state ( const std::string & plugin_key )

private

{
    std::lock_guard<std::mutex> state_lock(m_install_state_mutex);
 
    PluginDescriptor descriptor;
    std::vector<std::pair<std::string, bool>> capabilities;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
 
        const Plugin* plugin = find_plugin_locked(plugin_key);
        if (plugin == nullptr || !plugin->is_loaded())
            return;
 
        descriptor = plugin->descriptor;
        for (const auto& capability : plugin->capabilities)
            if (capability)
                capabilities.emplace_back(capability->name(), capability->is_enabled());
    }
 
    if (descriptor.plugin_root.empty())
        return;
 
    write_install_state(boost::filesystem::path(descriptor.plugin_root), descriptor, /*enabled=*/true, capabilities);
}

References Slic3r::Plugin::capabilities, Slic3r::Plugin::descriptor, find_plugin_locked(), Slic3r::Plugin::is_loaded(), m_install_state_mutex, m_mutex, Slic3r::PluginDescriptor::plugin_root, and Slic3r::write_install_state().

Referenced by initialize(), and set_capability_enabled().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_callbacks

std::map<CallbackType, std::vector<PluginLifecycleCompleteFn> > Slic3r::PluginManager::m_callbacks

private

Referenced by clear_callbacks(), copy_callbacks(), subscribe_on_load_callback(), and subscribe_on_unload_callback().

◆ m_cancelled

std::unordered_set<std::string> Slic3r::PluginManager::m_cancelled

private

Referenced by cancel_plugin_load_locked(), is_plugin_load_cancelled_locked(), and release_load_slot().

◆ m_capability_callbacks

std::map<CallbackType, std::vector<CapabilityLifecycleFn> > Slic3r::PluginManager::m_capability_callbacks

private

Referenced by clear_callbacks(), copy_capability_callbacks(), subscribe_on_capability_load_callback(), and subscribe_on_capability_unload_callback().

◆ m_cloud_service

CloudPluginService Slic3r::PluginManager::m_cloud_service

private

Referenced by delete_and_unsubscribe_cloud_plugin(), download_and_install_cloud_plugin(), fetch_plugins_from_cloud(), get_storage_dir(), set_cloud_agent(), subscribe_and_install_cloud_plugin(), and unsubscribe_cloud_plugin().

◆ m_cloud_user_id

std::string Slic3r::PluginManager::m_cloud_user_id

private

Referenced by delete_installed_plugin_package(), install_plugin(), keep_installed_plugin_as_local(), run_discovery_task(), set_cloud_user(), and update_cloud_plugin().

◆ m_config

PluginConfig Slic3r::PluginManager::m_config

private

Referenced by get_config(), get_config(), initialize(), load_plugin_impl(), and shutdown().

◆ m_discovery_complete

bool Slic3r::PluginManager::m_discovery_complete = false

private

Referenced by discover_plugins(), is_discovery_complete(), and run_discovery_task().

◆ m_discovery_cv

std::condition_variable Slic3r::PluginManager::m_discovery_cv

mutableprivate

Referenced by run_discovery_task(), and wait_for_discovery().

◆ m_discovery_error

std::string Slic3r::PluginManager::m_discovery_error

private

Referenced by discover_plugins(), get_discovery_error(), and run_discovery_task().

◆ m_discovery_in_progress

bool Slic3r::PluginManager::m_discovery_in_progress = false

private

Referenced by discover_plugins(), is_discovery_in_progress(), run_discovery_task(), shutdown(), and wait_for_discovery().

◆ m_initialized

bool Slic3r::PluginManager::m_initialized = false

private

Referenced by initialize(), and shutdown().

◆ m_install_state_mutex

std::mutex Slic3r::PluginManager::m_install_state_mutex

mutableprivate

Referenced by mark_plugin_install_state_disabled(), revoke_plugin_permissions(), and write_loaded_plugin_install_state().

◆ m_load_cv

std::condition_variable Slic3r::PluginManager::m_load_cv

mutableprivate

Referenced by notify_plugin_load_state_changed(), wait_for_all_plugin_loads(), wait_for_all_plugin_loads(), and wait_for_plugin_load().

◆ m_load_errors

std::map<std::string, std::string> Slic3r::PluginManager::m_load_errors

private

Referenced by cancel_plugin_load_locked(), get_plugin_load_error(), load_plugin(), load_plugin_impl(), and wait_for_plugin_load().

◆ m_load_in_progress

std::unordered_set<std::string> Slic3r::PluginManager::m_load_in_progress

private

Referenced by cancel_plugin_load_locked(), is_plugin_load_in_progress(), load_plugin(), release_load_slot(), shutdown(), wait_for_all_plugin_loads(), wait_for_all_plugin_loads(), and wait_for_plugin_load().

◆ m_missing_plugin_keys

std::unordered_set<std::string> Slic3r::PluginManager::m_missing_plugin_keys

private

Referenced by get_missing_plugin_descriptors(), merge_discovered_plugins(), and remove_missing_plugins().

◆ m_mutex

std::mutex Slic3r::PluginManager::m_mutex

mutableprivate

Referenced by cancel_plugin_load(), clear_callbacks(), clear_plugin_error(), copy_callbacks(), copy_capability_callbacks(), delete_installed_plugin_package(), discover_plugins(), download_and_install_cloud_plugin(), fetch_plugins_from_cloud(), finalize_cloud_plugin_removal(), get_discovery_error(), get_enabled_plugin_keys(), get_missing_plugin_descriptors(), get_plugin_capabilities(), get_plugin_capability(), get_plugin_capability(), get_plugin_descriptors(), get_plugin_load_error(), initialize(), install_plugin(), is_discovery_complete(), is_discovery_in_progress(), is_plugin_load_in_progress(), is_plugin_loaded(), keep_installed_plugin_as_local(), load_plugin(), load_plugin_impl(), mark_plugin_install_state_disabled(), merge_discovered_plugins(), release_load_slot(), remove_missing_plugins(), run_discovery_task(), set_capability_enabled(), set_cloud_user(), set_plugin_error(), shutdown(), subscribe_on_capability_load_callback(), subscribe_on_capability_unload_callback(), subscribe_on_load_callback(), subscribe_on_unload_callback(), try_get_plugin_descriptor(), try_get_plugin_descriptor_for_capability(), try_get_valid_plugin_descriptor(), unload_all_plugins(), unload_and_erase_if(), unload_cloud_plugins(), unload_plugin(), update_cloud_metadata(), update_cloud_plugin(), wait_for_all_plugin_loads(), wait_for_all_plugin_loads(), wait_for_discovery(), wait_for_plugin_load(), and write_loaded_plugin_install_state().

◆ m_plugins

◆ m_shutting_down

std::atomic<bool> Slic3r::PluginManager::m_shutting_down {false}

private

343{false};

Referenced by initialize(), is_shutting_down(), launch_script_capability(), load_plugin(), set_shutting_down(), and unload_plugin().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PluginManager.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PluginManager.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::PluginManager::ScriptLaunchResult

Member Typedef Documentation

◆ CapabilityLifecycleFn

◆ PluginLifecycleCompleteFn

◆ ScriptCompletionFn

Member Enumeration Documentation

◆ CallbackType

Constructor & Destructor Documentation

◆ ~PluginManager()

◆ PluginManager() [1/2]

◆ PluginManager() [2/2]

Member Function Documentation

◆ cancel_and_wait_for_capabilities()

◆ cancel_plugin_load()

◆ cancel_plugin_load_locked()

◆ check_registry_locked()

◆ clear_callbacks()

◆ clear_cloud_plugin_metadata()

◆ clear_plugin_error()

◆ copy_callbacks()

◆ copy_capability_callbacks()

◆ delete_and_unsubscribe_cloud_plugin()

◆ delete_installed_plugin_package()

◆ delete_plugin()

◆ discover_plugins()

◆ dispatch_lifecycle_event()

◆ download_and_install_cloud_plugin()

◆ fetch_plugins_from_cloud()

◆ finalize_cloud_plugin_removal()

◆ find_plugin_locked() [1/2]

◆ find_plugin_locked() [2/2]

◆ get_config() [1/2]

◆ get_config() [2/2]

◆ get_discovery_error()

◆ get_enabled_plugin_keys()

◆ get_install_state()

◆ get_missing_plugin_descriptors()

◆ get_plugin_capabilities()

◆ get_plugin_capability() [1/2]

◆ get_plugin_capability() [2/2]

◆ get_plugin_descriptors()

◆ get_plugin_load_error()

◆ get_storage_dir()

◆ initialize()

◆ inspect_local_plugin_package()

◆ install_plugin() [1/2]

◆ install_plugin() [2/2]

◆ instance()

◆ is_discovery_complete()

◆ is_discovery_in_progress()

◆ is_plugin_load_cancelled_locked()

◆ is_plugin_load_in_progress()

◆ is_plugin_loaded()

◆ is_shutting_down()

◆ keep_installed_plugin_as_local()

◆ launch_script_capability()

◆ load_plugin()

◆ load_plugin_impl()

◆ mark_plugin_install_state_disabled()

◆ merge_discovered_plugins()

◆ notify_plugin_load_state_changed()

◆ operator=()

◆ release_load_slot()

◆ remove_missing_plugins()

◆ rescan_plugins()

◆ revoke_plugin_permissions()

◆ run_discovery()

◆ run_discovery_task()

◆ run_on_capability_load_callbacks()

◆ run_on_capability_unload_callbacks()

◆ run_on_load_callbacks()