Slic3r::GUI::RemovableDriveManager Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/RemovableDriveManager.hpp>

Collaboration diagram for Slic3r::GUI::RemovableDriveManager:

Classes
struct	RemovableDrivesStatus

Public Member Functions
	RemovableDriveManager ()=default
	RemovableDriveManager (RemovableDriveManager const &)=delete
void	operator= (RemovableDriveManager const &)=delete
	~RemovableDriveManager ()
void	init (wxEvtHandler *callback_evt_handler)
void	shutdown ()
std::string	get_removable_drive_path (const std::string &path)
bool	is_path_on_removable_drive (const std::string &path)
bool	set_and_verify_last_save_path (const std::string &path)
void	eject_drive ()
RemovableDrivesStatus	status ()
void	update ()
void	set_exporting_finished (bool b)

Private Member Functions
void	thread_proc ()
std::vector< DriveData >	search_for_removable_drives () const
std::string	get_removable_drive_from_path (const std::string &path)
std::vector< DriveData >::const_iterator	find_last_save_path_drive_data () const

Private Attributes
bool	m_initialized { false }
wxEvtHandler *	m_callback_evt_handler { nullptr }
boost::thread	m_thread
std::condition_variable	m_thread_stop_condition
std::mutex	m_thread_stop_mutex
bool	m_stop { false }
std::vector< DriveData >	m_current_drives
std::mutex	m_drives_mutex
std::mutex	m_inside_update_mutex
std::string	m_last_save_path
bool	m_exporting_finished

Detailed Description

---

Class Documentation

Slic3r::GUI::RemovableDriveManager::RemovableDrivesStatus

struct Slic3r::GUI::RemovableDriveManager::RemovableDrivesStatus

Class Members
bool	has_eject { false }
bool	has_removable_drives { false }

Constructor & Destructor Documentation

RemovableDriveManager() [1/2]

Slic3r::GUI::RemovableDriveManager::RemovableDriveManager ( )

default

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

Here is the caller graph for this function:

RemovableDriveManager() [2/2]

Slic3r::GUI::RemovableDriveManager::RemovableDriveManager ( RemovableDriveManager const & )

delete

References RemovableDriveManager().

Here is the call graph for this function:

~RemovableDriveManager()

Slic3r::GUI::RemovableDriveManager::~RemovableDriveManager ( )

inline

{ /*assert(! m_initialized);*/ }

Member Function Documentation

eject_drive()

void Slic3r::GUI::RemovableDriveManager::eject_drive

(

)

{
  if (m_last_save_path.empty())
    return;
 
#ifndef REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
  this->update();
#endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
#if __APPLE__
  // If eject is still pending on the eject thread, wait until it finishes.
  //FIXME while waiting for the eject thread to finish, the main thread is not pumping Cocoa messages, which may lead 
  // to blocking by the diskutil tool for a couple (up to 10) seconds. This is likely not critical, as the eject normally
  // finishes quickly.
  this->eject_thread_finish();
#endif
 
  BOOST_LOG_TRIVIAL(info) << "Ejecting started";
 
  DriveData drive_data;
  {
    std::scoped_lock<std::mutex> lock(m_drives_mutex);
    auto it_drive_data = this->find_last_save_path_drive_data();
    if (it_drive_data == m_current_drives.end())
      return;
    drive_data = *it_drive_data;
  }
 
  std::string correct_path(m_last_save_path);
#if __APPLE__
  // On Apple, run the eject asynchronously on a worker thread, see the discussion at GH issue #4844.
  m_eject_thread = new boost::thread([this, correct_path, drive_data]()
#endif
  {
    //std::cout<<"Ejecting "<<(*it).name<<" from "<< correct_path<<"\n";
    // there is no usable command in c++ so terminal command is used instead
    // but neither triggers "succesful safe removal messege"
    
    BOOST_LOG_TRIVIAL(info) << "Ejecting started";
    boost::process::ipstream istd_err;
      boost::process::child child(
#if __APPLE__   
      boost::process::search_path("diskutil"), "eject", correct_path.c_str(), (boost::process::std_out & boost::process::std_err) > istd_err);
    //Another option how to eject at mac. Currently not working.
    //used insted of system() command;
    //this->eject_device(correct_path);
#else
        boost::process::search_path("umount"), correct_path.c_str(), (boost::process::std_out & boost::process::std_err) > istd_err);
#endif
    std::string line;
    while (child.running() && std::getline(istd_err, line)) {
      BOOST_LOG_TRIVIAL(trace) << line;
    }
    // wait for command to finnish (blocks ui thread)
    std::error_code ec;
    child.wait(ec);
    bool success = false;
    if (ec) {
            // The wait call can fail
            // It can happen even in cases where the eject is sucessful, but better report it as failed.
            // We did not find a way to reliably retrieve the exit code of the process.
      BOOST_LOG_TRIVIAL(error) << "boost::process::child::wait() failed during Ejection. State of Ejection is unknown. Error code: " << ec.value();
    } else {
      int err = child.exit_code();
        if (err) {
          BOOST_LOG_TRIVIAL(error) << "Ejecting failed. Exit code: " << err;
        } else {
        BOOST_LOG_TRIVIAL(info) << "Ejecting finished";
        success = true;
      }
    }
    assert(m_callback_evt_handler);
    if (m_callback_evt_handler) 
      wxPostEvent(m_callback_evt_handler, RemovableDriveEjectEvent(EVT_REMOVABLE_DRIVE_EJECTED, std::pair<DriveData, bool>(drive_data, success)));
    if (success) {
      // Remove the drive_data from m_current drives, searching by value, not by pointer, as m_current_drives may get modified during
      // asynchronous execution on m_eject_thread.
      std::scoped_lock<std::mutex> lock(m_drives_mutex);
      auto it = std::find(m_current_drives.begin(), m_current_drives.end(), drive_data);
      if (it != m_current_drives.end())
        m_current_drives.erase(it);
    }
  }
#if __APPLE__
  );
#endif // __APPLE__
}

References find_last_save_path_drive_data(), m_callback_evt_handler, m_current_drives, m_drives_mutex, m_last_save_path, Slic3r::trace(), and update().

Here is the call graph for this function:

find_last_save_path_drive_data()

std::vector< DriveData >::const_iterator Slic3r::GUI::RemovableDriveManager::find_last_save_path_drive_data ( ) const

private

{
  return Slic3r::binary_find_by_predicate(m_current_drives.begin(), m_current_drives.end(),
    [this](const DriveData &data){ return data.path < m_last_save_path; }, 
    [this](const DriveData &data){ return data.path == m_last_save_path; });
}

References Slic3r::binary_find_by_predicate(), and m_current_drives.

Referenced by eject_drive(), and status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_removable_drive_from_path()

std::string Slic3r::GUI::RemovableDriveManager::get_removable_drive_from_path ( const std::string & path )

private

{
  std::string new_path(path);
  if (!boost::filesystem::is_directory(path)) {
    std::size_t found = path.find_last_of("/");
    if (found != std::string::npos)
      new_path.erase(found);
  }
 
  // check if same filesystem
  std::scoped_lock<std::mutex> lock(m_drives_mutex);
  for (const DriveData &drive_data : m_current_drives)
    if (search_for_drives_internal::compare_filesystem_id(new_path, drive_data.path))
      return drive_data.path;
  return std::string();
}

References Slic3r::GUI::search_for_drives_internal::compare_filesystem_id(), m_current_drives, and m_drives_mutex.

Referenced by set_and_verify_last_save_path().

Here is the call graph for this function:

Here is the caller graph for this function:

get_removable_drive_path()

std::string Slic3r::GUI::RemovableDriveManager::get_removable_drive_path

(

const std::string &

path

)

{
#ifndef REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
  this->update();
#endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
 
  std::size_t found = path.find_last_of("/");
  std::string new_path = found == path.size() - 1 ? path.substr(0, found) : path;
 
  std::scoped_lock<std::mutex> lock(m_drives_mutex);
  for (const DriveData &data : m_current_drives)
    if (search_for_drives_internal::compare_filesystem_id(new_path, data.path))
      return path;
  return m_current_drives.empty() ? std::string() : m_current_drives.front().path;
}

References Slic3r::GUI::search_for_drives_internal::compare_filesystem_id(), m_current_drives, m_drives_mutex, and update().

Referenced by Slic3r::GUI::Plater::export_gcode(), and is_path_on_removable_drive().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::RemovableDriveManager::init

(

wxEvtHandler *

callback_evt_handler

)

{
  //no need use assert
  assert(! m_initialized);
  assert(m_callback_evt_handler == nullptr);
 
  if (m_initialized)
    return;
 
  m_initialized = true;
  m_callback_evt_handler = callback_evt_handler;
 
#if __APPLE__
    this->register_window_osx();
#endif
 
#ifdef REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
  this->update();
#else // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
  // Don't call update() manually, as the UI triggered APIs call this->update() anyways.
  m_thread = boost::thread((boost::bind(&RemovableDriveManager::thread_proc, this)));
#endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
}

References m_callback_evt_handler, m_initialized, m_thread, thread_proc(), and update().

Here is the call graph for this function:

is_path_on_removable_drive()

bool Slic3r::GUI::RemovableDriveManager::is_path_on_removable_drive ( const std::string & path )

inline

{ return this->get_removable_drive_path(path) == path; }

References get_removable_drive_path().

Referenced by Slic3r::GUI::Plater::export_gcode_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

void Slic3r::GUI::RemovableDriveManager::operator= ( RemovableDriveManager const & )

delete

References RemovableDriveManager().

Here is the call graph for this function:

search_for_removable_drives()

std::vector< DriveData > Slic3r::GUI::RemovableDriveManager::search_for_removable_drives ( ) const

private

{
  std::vector<DriveData> current_drives;
 
#if __APPLE__
 
  this->list_devices(current_drives);
 
#else
 
    if (platform_flavor() == PlatformFlavor::LinuxOnChromium) {
      // ChromeOS specific: search /mnt/chromeos/removable/* folder
    search_for_drives_internal::search_path("/mnt/chromeos/removable/*", "/mnt/chromeos/removable", current_drives);
    } else {
      //search /media/* folder
    search_for_drives_internal::search_path("/media/*", "/media", current_drives);
 
    //search_path("/Volumes/*", "/Volumes");
    std::string path = wxGetUserId().ToUTF8().data();
    std::string pp(path);
 
    //search /media/USERNAME/* folder
    pp = "/media/"+pp;
    path = "/media/" + path + "/*";
    search_for_drives_internal::search_path(path, pp, current_drives);
 
    //search /run/media/USERNAME/* folder
    path = "/run" + path;
    pp = "/run"+pp;
    search_for_drives_internal::search_path(path, pp, current_drives);
  }
 
#endif
 
  return current_drives;
}

References Slic3r::LinuxOnChromium, Slic3r::platform_flavor(), and Slic3r::GUI::search_for_drives_internal::search_path().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

set_and_verify_last_save_path()

bool Slic3r::GUI::RemovableDriveManager::set_and_verify_last_save_path

(

const std::string &

path

)

{
#ifndef REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
  this->update();
#endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
 
#ifdef __APPLE__
  m_last_save_path = path;
#else
  m_last_save_path = this->get_removable_drive_from_path(path);
#endif
 
  
  m_exporting_finished = false;
  return ! m_last_save_path.empty();
}

References get_removable_drive_from_path(), m_exporting_finished, m_last_save_path, and update().

Referenced by Slic3r::GUI::Plater::export_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

set_exporting_finished()

void Slic3r::GUI::RemovableDriveManager::set_exporting_finished ( bool b )

inline

{ m_exporting_finished = b; }

References m_exporting_finished.

shutdown()

void Slic3r::GUI::RemovableDriveManager::shutdown

(

)

{
#if __APPLE__
  // If eject is still pending on the eject thread, wait until it finishes.
  //FIXME while waiting for the eject thread to finish, the main thread is not pumping Cocoa messages, which may lead 
  // to blocking by the diskutil tool for a couple (up to 10) seconds. This is likely not critical, as the eject normally
  // finishes quickly.
  this->eject_thread_finish();
#endif
 
#ifndef REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
    if (m_thread.joinable()) {
      // Stop the worker thread, if running.
    {
      // Notify the worker thread to cancel wait on detection polling.
      std::lock_guard<std::mutex> lck(m_thread_stop_mutex);
      m_stop = true;
    }
    m_thread_stop_condition.notify_all();
    // Wait for the worker thread to stop.
    m_thread.join();
    m_stop = false;
  }
#endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS
 
  m_initialized = false;
  m_callback_evt_handler = nullptr;
}

References m_callback_evt_handler, m_initialized, m_stop, m_thread, m_thread_stop_condition, and m_thread_stop_mutex.

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

Here is the caller graph for this function:

status()

RemovableDriveManager::RemovableDrivesStatus Slic3r::GUI::RemovableDriveManager::status

(

)

{
 
  RemovableDriveManager::RemovableDrivesStatus out;
  {
    std::scoped_lock<std::mutex> lock(m_drives_mutex);
    out.has_eject = 
      // Cannot control eject on Chromium.
      platform_flavor() != PlatformFlavor::LinuxOnChromium &&
      this->find_last_save_path_drive_data() != m_current_drives.end();
    out.has_removable_drives = ! m_current_drives.empty();
  }
  if (! out.has_eject) 
    m_last_save_path.clear();
  out.has_eject = out.has_eject && m_exporting_finished;
  return out;
}

References find_last_save_path_drive_data(), Slic3r::GUI::RemovableDriveManager::RemovableDrivesStatus::has_eject, Slic3r::GUI::RemovableDriveManager::RemovableDrivesStatus::has_removable_drives, Slic3r::LinuxOnChromium, m_current_drives, m_drives_mutex, m_exporting_finished, m_last_save_path, and Slic3r::platform_flavor().

Here is the call graph for this function:

thread_proc()

void Slic3r::GUI::RemovableDriveManager::thread_proc ( )

private

{
  // Signal the worker thread to update initially.
#ifdef _WIN32
    m_wakeup = true;
#endif // _WIN32
 
  for (;;) {
    // Wait for 2 seconds before running the disk enumeration.
    // Cancellable.
    {
      std::unique_lock<std::mutex> lck(m_thread_stop_mutex);
#ifdef _WIN32
      // Reacting to updates by WM_DEVICECHANGE and WM_USER_MEDIACHANGED
      m_thread_stop_condition.wait(lck, [this]{ return m_stop || m_wakeup; });
#else
      m_thread_stop_condition.wait_for(lck, std::chrono::seconds(2), [this]{ return m_stop; });
#endif
    }
    if (m_stop)
      // Stop the worker thread.
      break;
    // Update m_current drives and send out update events.
    this->update();
  }
}

References m_stop, m_thread_stop_condition, m_thread_stop_mutex, and update().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void Slic3r::GUI::RemovableDriveManager::update

(

)

{
  std::unique_lock<std::mutex> inside_update_lock(m_inside_update_mutex, std::defer_lock);
#ifdef _WIN32
  // All wake up calls up to now are now consumed when the drive enumeration starts.
  m_wakeup = false;
#endif // _WIN32
  if (inside_update_lock.try_lock()) {
    // Got the lock without waiting. That means, the update was not running.
    // Run the update.
    std::vector<DriveData> current_drives = this->search_for_removable_drives();
    // Post update events.
    std::scoped_lock<std::mutex> lock(m_drives_mutex);
    std::sort(current_drives.begin(), current_drives.end());
    if (current_drives != m_current_drives) {
      assert(m_callback_evt_handler);
      if (m_callback_evt_handler)
        wxPostEvent(m_callback_evt_handler, RemovableDrivesChangedEvent(EVT_REMOVABLE_DRIVES_CHANGED));
    }
    m_current_drives = std::move(current_drives);
  } else {
    // Acquiring the m_iniside_update lock failed, therefore another update is running.
    // Just block until the other instance of update() finishes.
    inside_update_lock.lock();
  }
}

References m_callback_evt_handler, m_current_drives, m_drives_mutex, m_inside_update_mutex, and search_for_removable_drives().

Referenced by eject_drive(), get_removable_drive_path(), init(), set_and_verify_last_save_path(), and thread_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_callback_evt_handler

wxEvtHandler* Slic3r::GUI::RemovableDriveManager::m_callback_evt_handler { nullptr }

private

{ nullptr };

Referenced by eject_drive(), init(), shutdown(), and update().

m_current_drives

std::vector<DriveData> Slic3r::GUI::RemovableDriveManager::m_current_drives

private

Referenced by eject_drive(), find_last_save_path_drive_data(), get_removable_drive_from_path(), get_removable_drive_path(), status(), and update().

m_drives_mutex

std::mutex Slic3r::GUI::RemovableDriveManager::m_drives_mutex

mutableprivate

Referenced by eject_drive(), get_removable_drive_from_path(), get_removable_drive_path(), status(), and update().

m_exporting_finished

bool Slic3r::GUI::RemovableDriveManager::m_exporting_finished

private

Referenced by set_and_verify_last_save_path(), set_exporting_finished(), and status().

m_initialized

bool Slic3r::GUI::RemovableDriveManager::m_initialized { false }

private

{ false };

Referenced by init(), and shutdown().

m_inside_update_mutex

std::mutex Slic3r::GUI::RemovableDriveManager::m_inside_update_mutex

mutableprivate

Referenced by update().

m_last_save_path

std::string Slic3r::GUI::RemovableDriveManager::m_last_save_path

private

Referenced by eject_drive(), set_and_verify_last_save_path(), and status().

m_stop

bool Slic3r::GUI::RemovableDriveManager::m_stop { false }

private

{ false };

Referenced by shutdown(), and thread_proc().

m_thread

boost::thread Slic3r::GUI::RemovableDriveManager::m_thread

private

Referenced by init(), and shutdown().

m_thread_stop_condition

std::condition_variable Slic3r::GUI::RemovableDriveManager::m_thread_stop_condition

private

Referenced by shutdown(), and thread_proc().

m_thread_stop_mutex

std::mutex Slic3r::GUI::RemovableDriveManager::m_thread_stop_mutex

mutableprivate

Referenced by shutdown(), and thread_proc().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/RemovableDriveManager.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/RemovableDriveManager.cpp