Slic3r::InstanceLock Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/InstanceLock.hpp>

Collaboration diagram for Slic3r::InstanceLock:

Classes
struct	Slot

Public Member Functions
	InstanceLock (const std::string &lock_file_path, std::chrono::milliseconds timeout=default_timeout)
	~InstanceLock ()
	InstanceLock (const InstanceLock &)=delete
InstanceLock &	operator= (const InstanceLock &)=delete
bool	locked () const

Static Public Attributes
static constexpr std::chrono::milliseconds	default_timeout {1000}
static std::chrono::milliseconds	cooldown {10000}

Static Private Member Functions
static Slot &	slot_for (const std::string &lock_file_path)
static bool	open_lock_file (Slot &slot, const std::string &lock_file_path)
static void	defer (Slot &slot, const std::string &reason)

Private Attributes
Slot *	m_slot {nullptr}
std::unique_lock< std::recursive_mutex >	m_slot_guard
bool	m_locked {false}

Detailed Description

---

Class Documentation

Slic3r::InstanceLock::Slot

struct Slic3r::InstanceLock::Slot

Collaboration diagram for Slic3r::InstanceLock::Slot:

Class Members
time_point	cooldown_until {}
int	depth {0}
unique_ptr< NativeFileLock >	file_lock
recursive_mutex	mutex

Constructor & Destructor Documentation

InstanceLock() [1/2]

Slic3r::InstanceLock::InstanceLock ( const std::string & lock_file_path, std::chrono::milliseconds timeout = default_timeout )

explicit

{
    if (lock_file_path.empty())
        return;
    m_slot       = &slot_for(lock_file_path);
    m_slot_guard = std::unique_lock<std::recursive_mutex>(m_slot->mutex);
    const auto now = std::chrono::steady_clock::now();
    if (m_slot->depth == 0 && now >= m_slot->cooldown_until && open_lock_file(*m_slot, lock_file_path)) {
        const auto deadline = now + timeout;
        bool       taken    = false;
        for (;;) {
            try {
                if ((taken = m_slot->file_lock->try_lock()))
                    break;
            } catch (const std::exception &e) {
                defer(*m_slot, "Cannot lock " + lock_file_path + ": " + e.what());
                break;
            }
            if (std::chrono::steady_clock::now() >= deadline) {
                defer(*m_slot, "Another instance has held " + lock_file_path + " for over " + std::to_string(timeout.count()) + " ms");
                break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
        }
        if (! taken)
            m_slot->file_lock.reset();
    }
    // Counted last, so a throw above leaves the slot exactly as it was found.
    ++ m_slot->depth;
    m_locked = m_slot->file_lock != nullptr;
}

References defer(), m_locked, m_slot, m_slot_guard, open_lock_file(), and slot_for().

Referenced by InstanceLock(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~InstanceLock()

Slic3r::InstanceLock::~InstanceLock

(

)

{
    if (m_slot == nullptr)
        return;
    if (-- m_slot->depth == 0 && m_slot->file_lock) {
        try {
            m_slot->file_lock->unlock();
        } catch (const std::exception &e) {
            BOOST_LOG_TRIVIAL(warning) << "Cannot unlock instance lock: " << e.what();
        }
        m_slot->file_lock.reset();
    }
}

References m_slot.

InstanceLock() [2/2]

Slic3r::InstanceLock::InstanceLock ( const InstanceLock & )

delete

References InstanceLock().

Here is the call graph for this function:

Member Function Documentation

defer()

void Slic3r::InstanceLock::defer ( Slot & slot, const std::string & reason )

staticprivate

{
    slot.cooldown_until = std::chrono::steady_clock::now() + cooldown;
    BOOST_LOG_TRIVIAL(warning) << reason << "; proceeding without the lock for the next " << cooldown.count() << " ms";
}

References cooldown, and Slic3r::InstanceLock::Slot::cooldown_until.

Referenced by InstanceLock(), and open_lock_file().

Here is the caller graph for this function:

locked()

bool Slic3r::InstanceLock::locked ( ) const

inline

{ return m_locked; }

References m_locked.

Referenced by Slic3r::PresetBundle::migrate_legacy_user_filament_presets().

Here is the caller graph for this function:

open_lock_file()

bool Slic3r::InstanceLock::open_lock_file ( Slot & slot, const std::string & lock_file_path )

staticprivate

{
    try {
#ifdef _WIN32
        // The lock opens an existing file; created once, on the first miss.
        const std::wstring wide_path = boost::nowide::widen(lock_file_path);
        try {
            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
        } catch (const std::exception &) {
            boost::nowide::ofstream(lock_file_path, std::ios::app).close();
            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
        }
#else
        slot.file_lock = std::make_unique<NativeFileLock>(lock_file_path.c_str());
#endif
        return true;
    } catch (const std::exception &e) {
        defer(slot, "Cannot open lock file " + lock_file_path + ": " + e.what() + " (check its owner and permissions)");
        return false;
    }
}

References defer(), and Slic3r::InstanceLock::Slot::file_lock.

Referenced by InstanceLock().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

delete

References InstanceLock().

Here is the call graph for this function:

slot_for()

InstanceLock::Slot & Slic3r::InstanceLock::slot_for ( const std::string & lock_file_path )

staticprivate

{
    // Never freed: a save during static destruction still needs its slot.
    static auto *registry_mutex = new std::mutex();
    static auto *registry       = new std::map<std::string, std::unique_ptr<Slot>>();
 
    std::lock_guard<std::mutex> guard(*registry_mutex);
    std::unique_ptr<Slot> &slot = (*registry)[lock_file_path];
    if (! slot)
        slot = std::make_unique<Slot>();
    return *slot;
}

Referenced by InstanceLock().

Here is the caller graph for this function:

Member Data Documentation

cooldown

std::chrono::milliseconds Slic3r::InstanceLock::cooldown {10000}

inlinestatic

{10000};

Referenced by defer().

default_timeout

std::chrono::milliseconds Slic3r::InstanceLock::default_timeout {1000}

staticconstexpr

{1000};

m_locked

bool Slic3r::InstanceLock::m_locked {false}

private

{false};

Referenced by InstanceLock(), and locked().

m_slot

Slot* Slic3r::InstanceLock::m_slot {nullptr}

private

{nullptr};

Referenced by InstanceLock(), and ~InstanceLock().

m_slot_guard

std::unique_lock<std::recursive_mutex> Slic3r::InstanceLock::m_slot_guard

private

Referenced by InstanceLock().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/InstanceLock.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/InstanceLock.cpp