Slic3r::PresetUpdater Class Reference

#include <src/slic3r/Utils/PresetUpdater.hpp>

Collaboration diagram for Slic3r::PresetUpdater:

Classes
struct	priv

Public Types
enum	UpdateResult {   R_NOOP , R_INCOMPAT_EXIT , R_INCOMPAT_CONFIGURED , R_UPDATE_INSTALLED ,   R_UPDATE_REJECT , R_UPDATE_NOTIFICATION , R_ALL_CANCELED }
enum class	UpdateParams { SHOW_TEXT_BOX , SHOW_NOTIFICATION , FORCED_BEFORE_WIZARD }

Public Member Functions
	PresetUpdater ()
	PresetUpdater (PresetUpdater &&)=delete
	PresetUpdater (const PresetUpdater &)=delete
PresetUpdater &	operator= (PresetUpdater &&)=delete
PresetUpdater &	operator= (const PresetUpdater &)=delete
	~PresetUpdater ()
void	sync (const PresetBundle *preset_bundle)
void	cancel_sync ()
void	slic3r_update_notify ()
UpdateResult	config_update (const Semver &old_slic3r_version, UpdateParams params) const
void	update_index_db ()
bool	install_bundles_rsrc_or_cache_vendor (std::vector< std::string > bundles, bool snapshot=true) const
void	on_update_notification_confirm ()
bool	version_check_enabled () const

Private Attributes
std::unique_ptr< priv >	p

Detailed Description

Member Enumeration Documentation

UpdateParams

enum class Slic3r::PresetUpdater::UpdateParams

strong

Enumerator
SHOW_TEXT_BOX
SHOW_NOTIFICATION
FORCED_BEFORE_WIZARD

                          {
    SHOW_TEXT_BOX,        // force modal textbox
    SHOW_NOTIFICATION,      // only shows notification
    FORCED_BEFORE_WIZARD    // indicates that check of updated is forced before ConfigWizard opening
  };

UpdateResult

enum Slic3r::PresetUpdater::UpdateResult

Enumerator
R_NOOP
R_INCOMPAT_EXIT
R_INCOMPAT_CONFIGURED
R_UPDATE_INSTALLED
R_UPDATE_REJECT
R_UPDATE_NOTIFICATION
R_ALL_CANCELED

                    {
    R_NOOP,
    R_INCOMPAT_EXIT,
    R_INCOMPAT_CONFIGURED,
    R_UPDATE_INSTALLED,
    R_UPDATE_REJECT,
    R_UPDATE_NOTIFICATION,
    R_ALL_CANCELED
  };

Constructor & Destructor Documentation

PresetUpdater() [1/3]

Slic3r::PresetUpdater::PresetUpdater

(

)

                             :
  p(new priv())
{}

PresetUpdater() [2/3]

Slic3r::PresetUpdater::PresetUpdater ( PresetUpdater &&  )

delete

PresetUpdater() [3/3]

Slic3r::PresetUpdater::PresetUpdater ( const PresetUpdater &  )

delete

~PresetUpdater()

Slic3r::PresetUpdater::~PresetUpdater

(

)

{
  if (p && p->thread.joinable()) {
    // This will stop transfers being done by the thread, if any.
    // Cancelling takes some time, but should complete soon enough.
    p->cancel = true;
    p->thread.join();
  }
}

References p.

Member Function Documentation

cancel_sync()

void Slic3r::PresetUpdater::cancel_sync

(

)

{
  if (p && p->thread.joinable()) {
    // This will stop transfers being done by the thread, if any.
    // Cancelling takes some time, but should complete soon enough.
    p->cancel = true;
    p->thread.join();
  }
}

References p.

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

Here is the caller graph for this function:

config_update()

PresetUpdater::UpdateResult Slic3r::PresetUpdater::config_update	(	const Semver &	old_slic3r_version,
		UpdateParams	params
	)		const

{
  if (! p->enabled_config_update) { return R_NOOP; }
 
  auto updates = p->get_config_updates(old_slic3r_version);
  if (updates.incompats.size() > 0) {
    BOOST_LOG_TRIVIAL(info) << format("%1% bundles incompatible. Asking for action...", updates.incompats.size());
 
    std::unordered_map<std::string, wxString> incompats_map;
    for (const auto &incompat : updates.incompats) {
      const auto min_slic3r = incompat.version.min_slic3r_version;
      const auto max_slic3r = incompat.version.max_slic3r_version;
      wxString restrictions;
      if (min_slic3r != Semver::zero() && max_slic3r != Semver::inf()) {
                restrictions = GUI::format_wxstr(_L("requires min. %s and max. %s"),
                    min_slic3r.to_string(),
                    max_slic3r.to_string());
      } else if (min_slic3r != Semver::zero()) {
        restrictions = GUI::format_wxstr(_L("requires min. %s"), min_slic3r.to_string());
        BOOST_LOG_TRIVIAL(debug) << "Bundle is not downgrade, user will now have to do whole wizard. This should not happen.";
      } else {
                restrictions = GUI::format_wxstr(_L("requires max. %s"), max_slic3r.to_string());
      }
 
      incompats_map.emplace(std::make_pair(incompat.vendor, std::move(restrictions)));
    }
 
    GUI::MsgDataIncompatible dlg(std::move(incompats_map));
    const auto res = dlg.ShowModal();
    if (res == wxID_REPLACE) {
      BOOST_LOG_TRIVIAL(info) << "User wants to re-configure...";
 
      // This effectively removes the incompatible bundles:
      // (snapshot is taken beforehand)
      if (! p->perform_updates(std::move(updates)) ||
        ! GUI::wxGetApp().run_wizard(GUI::ConfigWizard::RR_DATA_INCOMPAT))
        return R_INCOMPAT_EXIT;
 
      return R_INCOMPAT_CONFIGURED;
    }
    else {
      BOOST_LOG_TRIVIAL(info) << "User wants to exit Slic3r, bye...";
      return R_INCOMPAT_EXIT;
    }
 
  } else if (updates.updates.size() > 0) {
 
    bool incompatible_version = false;
    for (const auto& update : updates.updates) {
      incompatible_version = (update.forced_update ? true : incompatible_version);
      //td::cout << update.forced_update << std::endl;
      //BOOST_LOG_TRIVIAL(info) << format("Update requires higher version.");
    }
 
    //forced update
    if (incompatible_version)
    {
      BOOST_LOG_TRIVIAL(info) << format("Update of %1% bundles available. At least one requires higher version of Slicer.", updates.updates.size());
 
      std::vector<GUI::MsgUpdateForced::Update> updates_msg;
      for (const auto& update : updates.updates) {
        std::string changelog_url = update.version.config_version.prerelease() == nullptr ? update.changelog_url : std::string();
        updates_msg.emplace_back(update.vendor, update.version.config_version, update.version.comment, std::move(changelog_url));
      }
 
      GUI::MsgUpdateForced dlg(updates_msg);
 
      const auto res = dlg.ShowModal();
      if (res == wxID_OK) {
        BOOST_LOG_TRIVIAL(info) << "User wants to update...";
        if (! p->perform_updates(std::move(updates)) ||
          ! reload_configs_update_gui())
          return R_INCOMPAT_EXIT;
        return R_UPDATE_INSTALLED;
      }
      else {
        BOOST_LOG_TRIVIAL(info) << "User wants to exit Slic3r, bye...";
        return R_INCOMPAT_EXIT;
      }
    }
 
    // regular update
    if (params == UpdateParams::SHOW_NOTIFICATION) {
      p->set_waiting_updates(updates);
      GUI::wxGetApp().plater()->get_notification_manager()->push_notification(GUI::NotificationType::PresetUpdateAvailable);
    }
    else {
      BOOST_LOG_TRIVIAL(info) << format("Update of %1% bundles available. Asking for confirmation ...", p->waiting_updates.updates.size());
 
      std::vector<GUI::MsgUpdateConfig::Update> updates_msg;
      for (const auto& update : updates.updates) {
        std::string changelog_url = update.version.config_version.prerelease() == nullptr ? update.changelog_url : std::string();
        updates_msg.emplace_back(update.vendor, update.version.config_version, update.version.comment, std::move(changelog_url));
      }
 
      GUI::MsgUpdateConfig dlg(updates_msg, params == UpdateParams::FORCED_BEFORE_WIZARD);
 
      const auto res = dlg.ShowModal();
      if (res == wxID_OK) {
        BOOST_LOG_TRIVIAL(debug) << "User agreed to perform the update";
        if (! p->perform_updates(std::move(updates)) ||
          ! reload_configs_update_gui())
          return R_ALL_CANCELED;
        return R_UPDATE_INSTALLED;
      }
      else {
        BOOST_LOG_TRIVIAL(info) << "User refused the update";
        if (params == UpdateParams::FORCED_BEFORE_WIZARD && res == wxID_CANCEL)
          return R_ALL_CANCELED;
        return R_UPDATE_REJECT;
      }
    }
    
    // MsgUpdateConfig will show after the notificaation is clicked
  } else {
    BOOST_LOG_TRIVIAL(info) << "No configuration updates available.";
  }
 
  return R_NOOP;
}

References _L, FORCED_BEFORE_WIZARD, Slic3r::format(), Slic3r::GUI::format_wxstr(), Slic3r::Semver::inf(), p, Slic3r::GUI::PresetUpdateAvailable, R_ALL_CANCELED, R_INCOMPAT_CONFIGURED, R_INCOMPAT_EXIT, R_NOOP, R_UPDATE_INSTALLED, R_UPDATE_REJECT, Slic3r::reload_configs_update_gui(), Slic3r::GUI::ConfigWizard::RR_DATA_INCOMPAT, SHOW_NOTIFICATION, updates, and Slic3r::Semver::zero().

Referenced by Slic3r::GUI::GUI_App::check_updates(), and Slic3r::GUI::GUI_App::run_wizard().

Here is the call graph for this function:

Here is the caller graph for this function:

install_bundles_rsrc_or_cache_vendor()

bool Slic3r::PresetUpdater::install_bundles_rsrc_or_cache_vendor	(	std::vector< std::string >	bundles,
		bool	snapshot = true
	)		const

{
  Updates updates;
 
  BOOST_LOG_TRIVIAL(info) << format("Installing %1% bundles from resources ...", bundles.size());
 
  for (const auto &bundle : bundles) {
    auto path_in_rsrc = (p->rsrc_path / bundle).replace_extension(".ini");
    auto path_in_cache_vendor = (p->cache_vendor_path / bundle).replace_extension(".ini");
    auto path_in_vendors = (p->vendor_path / bundle).replace_extension(".ini");
 
    bool is_in_rsrc = fs::exists(path_in_rsrc);
    bool is_in_cache_vendor = fs::exists(path_in_cache_vendor) && !fs::is_empty(path_in_cache_vendor);
 
    // Find if in cache vendor is newer version than in resources.
    // But we also need to mind too new versions - have to read index.
 
    // Fresh index should be in archive_dir, otherwise look for it in cache 
    fs::path idx_path (path_in_cache_vendor);
    idx_path.replace_extension(".idx");
    if (!boost::filesystem::exists(idx_path)) {
      BOOST_LOG_TRIVIAL(error) << GUI::format("Couldn't locate idx file %1% when performing updates.", idx_path.string());
      idx_path = fs::path(p->cache_path / idx_path.filename());
    }
    if (!boost::filesystem::exists(idx_path)) {
      std::string msg = GUI::format(_L("Couldn't locate index file for vendor %1% when performing updates. The profile will not be installed."), bundle);
      BOOST_LOG_TRIVIAL(error) << msg;
      GUI::show_error(nullptr, msg);
      continue;
    }
    Slic3r::GUI::Config::Index index;
    try {
      index.load(idx_path);
    }
    catch (const std::exception& /* err */) {
      std::string msg = GUI::format(_L("Couldn't load index file for vendor %1% when performing updates. The profile will not be installed. Reason: Corrupted index file %2%."), bundle, idx_path.string());
      BOOST_LOG_TRIVIAL(error) << msg;
      GUI::show_error(nullptr, msg);
      continue;
    }
    const auto recommended_it = index.recommended();
    const auto recommended = recommended_it->config_version;
 
    if (is_in_cache_vendor) {
      Semver version_cache = Semver::zero();
      try {
        auto vp_cache = VendorProfile::from_ini(path_in_cache_vendor, false);
        version_cache = vp_cache.config_version;
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1%, message: %2%", path_in_cache_vendor, e.what());
        version_cache = Semver::zero();
      }
      if (version_cache > recommended)
        version_cache = Semver::zero();
 
      Semver version_rsrc = Semver::zero();
      try {
        if (is_in_rsrc) {
          auto vp = VendorProfile::from_ini(path_in_rsrc, false);
          version_rsrc = vp.config_version;
        }
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1%, message: %2%", path_in_rsrc, e.what());
        //continue;
        version_rsrc = Semver::zero();
      }
      // Should not happen!
      if (version_rsrc > recommended)
        version_rsrc = Semver::zero();
 
      if (version_cache == Semver::zero() && version_rsrc == Semver::zero()) {
        std::string msg = GUI::format(_L("Couldn't open profile file for vendor %1% when performing updates. The profile will not be installed. This installation might be corrupted."), bundle);
        BOOST_LOG_TRIVIAL(error) << msg;
        GUI::show_error(nullptr, msg);
        continue;
      } else if (version_cache == Semver::zero()) {
        // cache vendor cannot be used, use resources
        updates.updates.emplace_back(std::move(path_in_rsrc), std::move(path_in_vendors), Version(), "", "");
      } else if (version_rsrc == Semver::zero()) {
        // resources cannto be used, use cache vendor
        updates.updates.emplace_back(std::move(path_in_cache_vendor), std::move(path_in_vendors), Version(), "", "");
      } else if (version_cache > version_rsrc) {
        // in case we are installing from cache / vendor. we should also copy index to cache
        // This needs to be done now bcs the current one would be missing this version on the next start 
        auto  path_idx_cache = (p->cache_path / bundle).replace_extension(".idx");
        if (idx_path != path_idx_cache)
          copy_file_fix(idx_path, path_idx_cache);
        updates.updates.emplace_back(std::move(path_in_cache_vendor), std::move(path_in_vendors), Version(), "", "");
      } else {
        updates.updates.emplace_back(std::move(path_in_rsrc), std::move(path_in_vendors), Version(), "", "");
      }
    } else {
      if (! is_in_rsrc) {
        // This should not happen. Instead of an assert, make it crash in Release mode too.
        BOOST_LOG_TRIVIAL(error) << "Internal error in PresetUpdater! Terminating the application.";
        std::terminate();
      }
      updates.updates.emplace_back(std::move(path_in_rsrc), std::move(path_in_vendors), Version(), "", "");
    }
  }
 
  return p->perform_updates(std::move(updates), snapshot);
}

References _L, error, Slic3r::format(), Slic3r::GUI::format(), Slic3r::VendorProfile::from_ini(), Slic3r::GUI::Config::Index::load(), p, Slic3r::GUI::Config::Index::recommended(), Slic3r::GUI::show_error(), updates, and Slic3r::Semver::zero().

Referenced by Slic3r::GUI::ConfigWizard::priv::apply_config().

Here is the call graph for this function:

Here is the caller graph for this function:

on_update_notification_confirm()

void Slic3r::PresetUpdater::on_update_notification_confirm

(

)

{
  if (!p->has_waiting_updates)
    return;
  BOOST_LOG_TRIVIAL(info) << format("Update of %1% bundles available. Asking for confirmation ...", p->waiting_updates.updates.size());
 
  std::vector<GUI::MsgUpdateConfig::Update> updates_msg;
  for (const auto& update : p->waiting_updates.updates) {
    std::string changelog_url = update.version.config_version.prerelease() == nullptr ? update.changelog_url : std::string();
    updates_msg.emplace_back(update.vendor, update.version.config_version, update.version.comment, std::move(changelog_url));
  }
 
  GUI::MsgUpdateConfig dlg(updates_msg);
 
  const auto res = dlg.ShowModal();
  if (res == wxID_OK) {
    BOOST_LOG_TRIVIAL(debug) << "User agreed to perform the update";
    if (p->perform_updates(std::move(p->waiting_updates)) &&
      reload_configs_update_gui()) {
      p->has_waiting_updates = false;
    }
  }
  else {
    BOOST_LOG_TRIVIAL(info) << "User refused the update";
  } 
}

References Slic3r::format(), p, and Slic3r::reload_configs_update_gui().

Here is the call graph for this function:

operator=() [1/2]

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

delete

operator=() [2/2]

PresetUpdater & Slic3r::PresetUpdater::operator= ( PresetUpdater &&  )

delete

slic3r_update_notify()

void Slic3r::PresetUpdater::slic3r_update_notify

(

)

{
  if (! p->enabled_version_check)
    return;
  auto* app_config = GUI::wxGetApp().app_config;
  const auto ver_online_str = app_config->get("version_online");
  const auto ver_online = Semver::parse(ver_online_str);
  const auto ver_online_seen = Semver::parse(app_config->get("version_online_seen"));
 
  if (ver_online) {
    // Only display the notification if the version available online is newer AND if we haven't seen it before
    if (*ver_online > Slic3r::SEMVER && (! ver_online_seen || *ver_online_seen < *ver_online)) {
      GUI::MsgUpdateSlic3r notification(Slic3r::SEMVER, *ver_online);
      notification.ShowModal();
      if (notification.disable_version_check()) {
        app_config->set("notify_release", "none");
        p->enabled_version_check = false;
      }
    }
 
    app_config->set("version_online_seen", ver_online_str);
  }
}

References Slic3r::GUI::MsgUpdateSlic3r::disable_version_check(), p, Slic3r::Semver::parse(), and Slic3r::SEMVER.

Here is the call graph for this function:

sync()

void Slic3r::PresetUpdater::sync

(

const PresetBundle *

preset_bundle

)

{
  p->set_download_prefs(GUI::wxGetApp().app_config);
  if (!p->enabled_version_check && !p->enabled_config_update) { return; }
 
  // Copy the whole vendors data for use in the background thread
  // Unfortunatelly as of C++11, it needs to be copied again
  // into the closure (but perhaps the compiler can elide this).
  VendorMap vendors = preset_bundle->vendors;
  std::string index_archive_url = GUI::wxGetApp().app_config->index_archive_url();
 
    p->thread = std::thread([this, vendors, index_archive_url]() {
    this->p->prune_tmps();
    this->p->sync_config(std::move(vendors), index_archive_url);
    });
}

References p, and Slic3r::PresetBundle::vendors.

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

Here is the caller graph for this function:

update_index_db()

void Slic3r::PresetUpdater::update_index_db

(

)

{
  p->update_index_db();
}

References p.

Referenced by Slic3r::GUI::GUI_App::check_updates(), and Slic3r::GUI::GUI_App::run_wizard().

Here is the caller graph for this function:

version_check_enabled()

bool Slic3r::PresetUpdater::version_check_enabled

(

)

const

{
  return p->enabled_version_check;
}

References p.

Member Data Documentation

p

std::unique_ptr<priv> Slic3r::PresetUpdater::p

private

Referenced by ~PresetUpdater(), cancel_sync(), config_update(), install_bundles_rsrc_or_cache_vendor(), on_update_notification_confirm(), slic3r_update_notify(), sync(), update_index_db(), and version_check_enabled().

---

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

• src/slic3r/Utils/PresetUpdater.hpp
• src/slic3r/Utils/PresetUpdater.cpp