Slic3r::PresetUpdater::priv Struct Reference

Collaboration diagram for Slic3r::PresetUpdater::priv:

Public Member Functions
	priv ()
void	set_download_prefs (const AppConfig *app_config)
bool	get_file (const std::string &url, const fs::path &target_path) const
void	prune_tmps () const
void	sync_config (const VendorMap vendors, const std::string &index_archive_url)
void	check_install_indices () const
Updates	get_config_updates (const Semver &old_slic3r_version) const
bool	perform_updates (Updates &&updates, bool snapshot=true) const
void	set_waiting_updates (Updates u)
void	get_missing_resource (const std::string &vendor, const std::string &filename, const std::string &url) const
void	get_or_copy_missing_resource (const std::string &vendor, const std::string &filename, const std::string &url) const
void	update_index_db ()

Public Attributes
std::vector< Index >	index_db
bool	enabled_version_check
bool	enabled_config_update
std::string	version_check_url
fs::path	cache_path
fs::path	cache_vendor_path
fs::path	rsrc_path
fs::path	vendor_path
bool	cancel
std::thread	thread
bool	has_waiting_updates { false }
Updates	waiting_updates

Detailed Description

Constructor & Destructor Documentation

priv()

Slic3r::PresetUpdater::priv::priv

(

)

  : cache_path(fs::path(Slic3r::data_dir()) / "cache")
  , cache_vendor_path(cache_path / "vendor")
  , rsrc_path(fs::path(resources_dir()) / "profiles")
  , vendor_path(fs::path(Slic3r::data_dir()) / "vendor")
  , cancel(false)
{
  set_download_prefs(GUI::wxGetApp().app_config);
  // Install indicies from resources. Only installs those that are either missing or older than in resources.
  check_install_indices();
  // Load indices from the cache directory.
  index_db = Index::load_db();
}

References check_install_indices(), index_db, and set_download_prefs().

Here is the call graph for this function:

Member Function Documentation

check_install_indices()

void Slic3r::PresetUpdater::priv::check_install_indices

(

)

const

{
  BOOST_LOG_TRIVIAL(info) << "Checking if indices need to be installed from resources...";
 
    for (auto &dir_entry : boost::filesystem::directory_iterator(rsrc_path))
    if (is_idx_file(dir_entry)) {
      const auto &path = dir_entry.path();
      const auto path_in_cache = cache_path / path.filename();
 
      if (! fs::exists(path_in_cache)) {
        BOOST_LOG_TRIVIAL(info) << "Install index from resources: " << path.filename();
        copy_file_fix(path, path_in_cache);
      } else {
        Index idx_rsrc, idx_cache;
        idx_rsrc.load(path);
        idx_cache.load(path_in_cache);
 
        if (idx_cache.version() < idx_rsrc.version()) {
          BOOST_LOG_TRIVIAL(info) << "Update index from resources: " << path.filename();
          copy_file_fix(path, path_in_cache);
        }
      }
    }
}

References Slic3r::is_idx_file(), Slic3r::GUI::Config::Index::load(), and Slic3r::GUI::Config::Index::version().

Referenced by priv().

Here is the call graph for this function:

Here is the caller graph for this function:

get_config_updates()

Updates Slic3r::PresetUpdater::priv::get_config_updates

(

const Semver &

old_slic3r_version

)

const

{
  Updates updates;
 
  BOOST_LOG_TRIVIAL(info) << "Checking for cached configuration updates...";
 
  // Over all indices from the cache directory:
    for (const Index& idx : index_db) {
    auto bundle_path = vendor_path / (idx.vendor() + ".ini");
    auto bundle_path_idx = vendor_path / idx.path().filename();
 
    if (! fs::exists(bundle_path)) {
      BOOST_LOG_TRIVIAL(info) << format("Confing bundle not installed for vendor %1%, skipping: ", idx.vendor());
      continue;
    }
 
    // Perform a basic load and check the version of the installed preset bundle.
    VendorProfile vp;
    try {
      vp = VendorProfile::from_ini(bundle_path, false);
    }
    catch (const std::exception& e) {
      BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", idx.vendor(), bundle_path, e.what());
      continue;
    }
    // Getting a recommended version from the latest index, wich may have been downloaded
    // from the internet, or installed / updated from the installation resources.
    auto recommended = idx.recommended();
    if (recommended == idx.end()) {
      BOOST_LOG_TRIVIAL(error) << format("No recommended version for vendor: %1%, invalid index? Giving up.", idx.vendor());
      // XXX: what should be done here?
      continue;
    }
 
    const auto ver_current = idx.find(vp.config_version);
    const bool ver_current_found = ver_current != idx.end();
 
    BOOST_LOG_TRIVIAL(debug) << format("Vendor: %1%, version installed: %2%%3%, version cached: %4%",
      vp.name,
      vp.config_version.to_string(),
      (ver_current_found ? "" : " (not found in index!)"),
      recommended->config_version.to_string());
 
    if (! ver_current_found) {
      // Any published config shall be always found in the latest config index.
      auto message = format("Preset bundle `%1%` version not found in index: %2%", idx.vendor(), vp.config_version.to_string());
      BOOST_LOG_TRIVIAL(error) << message;
      GUI::show_error(nullptr, message);
      continue;
    }
 
    bool current_not_supported = false; //if slcr is incompatible but situation is not downgrade, we do forced updated and this bool is information to do it 
 
    if (ver_current_found && !ver_current->is_current_slic3r_supported()){
      if (ver_current->is_current_slic3r_downgrade()) {
        // "Reconfigure" situation.
        BOOST_LOG_TRIVIAL(warning) << "Current Slic3r incompatible with installed bundle: " << bundle_path.string();
        updates.incompats.emplace_back(std::move(bundle_path), *ver_current, vp.name);
        continue;
      }
    current_not_supported = true;
    }
 
    if (recommended->config_version < vp.config_version) {
      BOOST_LOG_TRIVIAL(warning) << format("Recommended config version for the currently running PrusaSlicer is older than the currently installed config for vendor %1%. This should not happen.", idx.vendor());
      continue;
    }
 
    if (recommended->config_version == vp.config_version) {
      // The recommended config bundle is already installed.
      continue;
    }
 
    // Config bundle update situation. The recommended config bundle version for this PrusaSlicer version from the index from the cache is newer
    // than the version of the currently installed config bundle.
 
    // The config index inside the cache directory (given by idx.path()) is one of the following:
    // 1) The last config index downloaded by any previously running PrusaSlicer instance
    // 2) The last config index installed by any previously running PrusaSlicer instance (older or newer) from its resources.
    // 3) The last config index installed by the currently running PrusaSlicer instance from its resources.
    // The config index is always the newest one (given by its newest config bundle referenced), and older config indices shall fully contain
    // the content of the older config indices.
 
    // Config bundle inside the cache directory.
    fs::path path_in_cache    = cache_path / (idx.vendor() + ".ini");
    // Config bundle inside the resources directory.
    fs::path path_in_rsrc     = rsrc_path  / (idx.vendor() + ".ini");
    // Config index inside the resources directory.
    fs::path path_idx_in_rsrc   = rsrc_path  / (idx.vendor() + ".idx");
 
    // Search for a valid config bundle in the cache directory.
    bool    found = false;
    Update      new_update;
    fs::path  bundle_path_idx_to_install;
    if (fs::exists(path_in_cache)) {
      try {
        VendorProfile new_vp = VendorProfile::from_ini(path_in_cache, true);
        if (new_vp.config_version == recommended->config_version) {
          // The config bundle from the cache directory matches the recommended version of the index from the cache directory.
          // This is the newest known recommended config. Use it.
          if (!PresetUtils::vendor_profile_has_all_resources(new_vp)) {
            BOOST_LOG_TRIVIAL(warning) << "Some resources are missing for update of vedor " << new_vp.id;
          }
          new_update = Update(std::move(path_in_cache), std::move(bundle_path), *recommended, vp.name, vp.changelog_url, current_not_supported);
          // and install the config index from the cache into vendor's directory.
          bundle_path_idx_to_install = idx.path();
          found = true;
        }
      } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(info) << format("Failed to load the config bundle `%1%`: %2%", path_in_cache.string(), ex.what());
      }
    }
 
    // Keep the rsrc_idx outside of the next block, as we will reference the "recommended" version by an iterator.
    Index rsrc_idx;
    if (! found && fs::exists(path_in_rsrc) && fs::exists(path_idx_in_rsrc)) {
      // Trying the config bundle from resources (from the installation).
      // In that case, the recommended version number has to be compared against the recommended version reported by the config index from resources as well, 
      // as the config index in the cache directory may already be newer, recommending a newer config bundle than available in cache or resources.
      VendorProfile rsrc_vp;
      try {
        rsrc_vp = VendorProfile::from_ini(path_in_rsrc, false);
      } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(info) << format("Cannot load the config bundle at `%1%`: %2%", path_in_rsrc.string(), ex.what());
      }
      if (rsrc_vp.valid()) {
        try {
          rsrc_idx.load(path_idx_in_rsrc);
        } catch (const std::exception &ex) {
          BOOST_LOG_TRIVIAL(info) << format("Cannot load the config index at `%1%`: %2%", path_idx_in_rsrc.string(), ex.what());
        }
        recommended = rsrc_idx.recommended();
        if (recommended != rsrc_idx.end() && recommended->config_version == rsrc_vp.config_version && recommended->config_version > vp.config_version) {
          new_update = Update(std::move(path_in_rsrc), std::move(bundle_path), *recommended, vp.name, vp.changelog_url, current_not_supported);
          bundle_path_idx_to_install = path_idx_in_rsrc;
          found = true;
        } else {
          BOOST_LOG_TRIVIAL(warning) << format("The recommended config version for vendor `%1%` in resources does not match the recommended\n"
                                                   " config version for this version of PrusaSlicer. Corrupted installation?", idx.vendor());
        }
      }
    }
 
    if (found) {
      // Load 'installed' idx, if any.
      // 'Installed' indices are kept alongside the bundle in the `vendor` subdir
      // for bookkeeping to remember a cancelled update and not offer it again.
      if (fs::exists(bundle_path_idx)) {
        Index existing_idx;
        try {
          existing_idx.load(bundle_path_idx);
          // Find a recommended config bundle version for the slic3r version last executed. This makes sure that a config bundle update will not be missed
          // when upgrading an application. On the other side, the user will be bugged every time he will switch between slic3r versions.
                    /*const auto existing_recommended = existing_idx.recommended(old_slic3r_version);
                    if (existing_recommended != existing_idx.end() && recommended->config_version == existing_recommended->config_version) {
            // The user has already seen (and presumably rejected) this update
            BOOST_LOG_TRIVIAL(info) << format("Downloaded index for `%1%` is the same as installed one, not offering an update.",idx.vendor());
            continue;
          }*/
        } catch (const std::exception &err) {
          BOOST_LOG_TRIVIAL(error) << format("Cannot load the installed index at `%1%`: %2%", bundle_path_idx, err.what());
        }
      }
#if 0
      // Check if the update is already present in a snapshot
      if(!current_not_supported)
      {
        const auto recommended_snap = SnapshotDB::singleton().snapshot_with_vendor_preset(vp.name, recommended->config_version);
        if (recommended_snap != SnapshotDB::singleton().end()) {
          BOOST_LOG_TRIVIAL(info) << format("Bundle update %1% %2% already found in snapshot %3%, skipping...",
            vp.name,
            recommended->config_version.to_string(),
            recommended_snap->id);
          continue;
        }
      }
#endif // 0
      updates.updates.emplace_back(std::move(new_update));
      // 'Install' the index in the vendor directory. This is used to memoize
      // offered updates and to not offer the same update again if it was cancelled by the user.
      copy_file_fix(bundle_path_idx_to_install, bundle_path_idx);
    } else {
      BOOST_LOG_TRIVIAL(warning) << format("Index for vendor %1% indicates update (%2%) but the new bundle was found neither in cache nor resources",
        idx.vendor(),
        recommended->config_version.to_string());
    }
  }
 
  return updates;
}

References Slic3r::VendorProfile::changelog_url, Slic3r::VendorProfile::config_version, Slic3r::GUI::Config::Index::end(), error, Slic3r::format(), Slic3r::VendorProfile::from_ini(), Slic3r::VendorProfile::id, Slic3r::GUI::Config::Index::load(), Slic3r::VendorProfile::name, new_update(), Slic3r::GUI::Config::Index::recommended(), Slic3r::GUI::show_error(), Slic3r::Semver::to_string(), updates, Slic3r::VendorProfile::valid(), and Slic3r::PresetUtils::vendor_profile_has_all_resources().

Here is the call graph for this function:

get_file()

bool Slic3r::PresetUpdater::priv::get_file	(	const std::string &	url,
		const fs::path &	target_path
	)		const

{
  bool res = false;
  fs::path tmp_path = target_path;
  tmp_path += format(".%1%%2%", get_current_pid(), TMP_EXTENSION);
 
  BOOST_LOG_TRIVIAL(info) << format("Get: `%1%`\n\t-> `%2%`\n\tvia tmp path `%3%`",
    url,
    target_path.string(),
    tmp_path.string());
 
  Http::get(url)
        .on_progress([](Http::Progress, bool &cancel) {
      if (cancel) { cancel = true; }
    })
    .on_error([&](std::string body, std::string error, unsigned http_status) {
      (void)body;
      BOOST_LOG_TRIVIAL(error) << format("Error getting: `%1%`: HTTP %2%, %3%",
        url,
        http_status,
        error);
    })
    .on_complete([&](std::string body, unsigned /* http_status */) {
      fs::fstream file(tmp_path, std::ios::out | std::ios::binary | std::ios::trunc);
      file.write(body.c_str(), body.size());
      file.close();
      fs::rename(tmp_path, target_path);
      res = true;
    })
    .perform_sync();
 
  return res;
}

References error, Slic3r::format(), Slic3r::Http::get(), Slic3r::get_current_pid(), Slic3r::Http::on_progress(), Slic3r::TMP_EXTENSION, and void().

Here is the call graph for this function:

get_missing_resource()

void Slic3r::PresetUpdater::priv::get_missing_resource	(	const std::string &	vendor,
		const std::string &	filename,
		const std::string &	url
	)		const

{
  if (filename.empty() || vendor.empty())
    return;
 
  if (!boost::starts_with(url, "http://files.prusa3d.com/wp-content/uploads/repository/") &&
    !boost::starts_with(url, "https://files.prusa3d.com/wp-content/uploads/repository/"))
  {
    throw Slic3r::CriticalException(GUI::format("URL outside prusa3d.com network: %1%", url));
  }
 
  std::string escaped_filename = escape_string_url(filename);
  const fs::path file_in_vendor(vendor_path / (vendor + "/" + filename));
  const fs::path file_in_rsrc(rsrc_path / (vendor + "/" + filename));
  const fs::path file_in_cache(cache_path / (vendor + "/" + filename));
 
  if (fs::exists(file_in_vendor)) { // Already in vendor. No need to do anything.
    BOOST_LOG_TRIVIAL(info) << "Resource " << vendor << " / " << filename << " found in vendor folder. No need to download.";
    return;
  }
  if (fs::exists(file_in_rsrc)) { // In resources dir since installation. No need to do anything.
    BOOST_LOG_TRIVIAL(info) << "Resource " << vendor << " / " << filename << " found in resources folder. No need to download.";
    return;
  }
  if (fs::exists(file_in_cache)) { // In cache/venodr_name/ dir. No need to do anything.
    BOOST_LOG_TRIVIAL(info) << "Resource " << vendor << " / " << filename << " found in cache folder. No need to download.";
    return;
  }
 
  BOOST_LOG_TRIVIAL(info) << "Resources check could not find " << vendor << " / " << filename << " bed texture. Downloading.";
 
  const auto resource_url = format("%1%%2%%3%", url, url.back() == '/' ? "" : "/", escaped_filename); // vendor should already be in url 
 
  if (!fs::exists(file_in_cache.parent_path()))
    fs::create_directory(file_in_cache.parent_path());
 
  get_file(resource_url, file_in_cache);
  return;
}

References Slic3r::format(), and Slic3r::GUI::format().

Here is the call graph for this function:

get_or_copy_missing_resource()

void Slic3r::PresetUpdater::priv::get_or_copy_missing_resource	(	const std::string &	vendor,
		const std::string &	filename,
		const std::string &	url
	)		const

{
  if (filename.empty() || vendor.empty())
    return;
 
  std::string escaped_filename = escape_string_url(filename);
  const fs::path file_in_vendor(vendor_path / (vendor + "/" + filename));
  const fs::path file_in_rsrc(rsrc_path / (vendor + "/" + filename));
  const fs::path file_in_cache(cache_path / (vendor + "/" + filename));
 
  if (fs::exists(file_in_vendor)) { // Already in vendor. No need to do anything.
    BOOST_LOG_TRIVIAL(info) << "Resource " << vendor << " / " << filename << " found in vendor folder. No need to download.";
    return;
  }
  if (fs::exists(file_in_rsrc)) { // In resources dir since installation. No need to do anything.
    BOOST_LOG_TRIVIAL(info) << "Resource " << vendor << " / " << filename << " found in resources folder. No need to download.";
    return;
  }
  if (!fs::exists(file_in_cache)) { // No file to copy. Download it to straight to the vendor dir.
    if (!boost::starts_with(url, "http://files.prusa3d.com/wp-content/uploads/repository/") &&
      !boost::starts_with(url, "https://files.prusa3d.com/wp-content/uploads/repository/"))
    {
      throw Slic3r::CriticalException(GUI::format("URL outside prusa3d.com network: %1%", url));
    }
    BOOST_LOG_TRIVIAL(info) << "Downloading resources missing in cache directory: " << vendor << " / " << filename;
 
    const auto resource_url = format("%1%%2%%3%", url, url.back() == '/' ? "" : "/", escaped_filename); // vendor should already be in url 
 
    if (!fs::exists(file_in_vendor.parent_path()))
      fs::create_directory(file_in_vendor.parent_path());
 
    get_file(resource_url, file_in_vendor);
    return;
  }
 
  if (!fs::exists(file_in_vendor.parent_path())) // create vendor_name dir in vendor 
    fs::create_directory(file_in_vendor.parent_path());
 
  BOOST_LOG_TRIVIAL(debug) << "Copiing: " << file_in_cache << " to " << file_in_vendor;
  copy_file_fix(file_in_cache, file_in_vendor);
}

References Slic3r::format(), and Slic3r::GUI::format().

Here is the call graph for this function:

perform_updates()

bool Slic3r::PresetUpdater::priv::perform_updates	(	Updates &&	updates,
		bool	snapshot = true
	)		const

{
  if (updates.incompats.size() > 0) {
    if (snapshot) {
      BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
      if (! GUI::Config::take_config_snapshot_cancel_on_error(*GUI::wxGetApp().app_config, Snapshot::SNAPSHOT_DOWNGRADE, "",
        _u8L("Continue and install configuration updates?")))
        return false;
    }
    
    BOOST_LOG_TRIVIAL(info) << format("Deleting %1% incompatible bundles", updates.incompats.size());
 
    for (auto &incompat : updates.incompats) {
      BOOST_LOG_TRIVIAL(info) << '\t' << incompat;
      incompat.remove();
    }
 
    
  } else if (updates.updates.size() > 0) {
    
    if (snapshot) {
      BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
      if (! GUI::Config::take_config_snapshot_cancel_on_error(*GUI::wxGetApp().app_config, Snapshot::SNAPSHOT_UPGRADE, "",
        _u8L("Continue and install configuration updates?")))
        return false;
    }
 
    BOOST_LOG_TRIVIAL(info) << format("Performing %1% updates", updates.updates.size());
 
    wxProgressDialog progress_dialog(_L("Installing profiles"), _L("Installing profiles") , 100, nullptr, wxPD_AUTO_HIDE);
    progress_dialog.Pulse();
    
    for (const auto &update : updates.updates) {
      BOOST_LOG_TRIVIAL(info) << '\t' << update;
 
      update.install();
 
      PresetBundle bundle;
      // Throw when parsing invalid configuration. Only valid configuration is supposed to be provided over the air.
      bundle.load_configbundle(update.source.string(), PresetBundle::LoadConfigBundleAttribute::LoadSystem, ForwardCompatibilitySubstitutionRule::Disable);
 
      BOOST_LOG_TRIVIAL(info) << format("Deleting %1% conflicting presets", bundle.prints.size() + bundle.filaments.size() + bundle.printers.size());
 
      auto preset_remover = [](const Preset &preset) {
        BOOST_LOG_TRIVIAL(info) << '\t' << preset.file;
        fs::remove(preset.file);
      };
 
      for (const auto &preset : bundle.prints)    { preset_remover(preset); }
      for (const auto &preset : bundle.filaments) { preset_remover(preset); }
      for (const auto &preset : bundle.printers)  { preset_remover(preset); }
 
      // Also apply the `obsolete_presets` property, removing obsolete ini files
 
      BOOST_LOG_TRIVIAL(info) << format("Deleting %1% obsolete presets",
        bundle.obsolete_presets.prints.size() + bundle.obsolete_presets.filaments.size() + bundle.obsolete_presets.printers.size());
 
      auto obsolete_remover = [](const char *subdir, const std::string &preset) {
        auto path = fs::path(Slic3r::data_dir()) / subdir / preset;
        path += ".ini";
        BOOST_LOG_TRIVIAL(info) << '\t' << path.string();
        fs::remove(path);
      };
 
      for (const auto &name : bundle.obsolete_presets.prints)    { obsolete_remover("print", name); }
      for (const auto &name : bundle.obsolete_presets.filaments) { obsolete_remover("filament", name); }
      for (const auto &name : bundle.obsolete_presets.sla_prints) { obsolete_remover("sla_print", name); } 
      for (const auto &name : bundle.obsolete_presets.sla_materials/*filaments*/) { obsolete_remover("sla_material", name); } 
      for (const auto &name : bundle.obsolete_presets.printers)  { obsolete_remover("printer", name); }
      
      // check if any resorces of installed bundle are missing. If so, new ones should be already downloaded at cache/vendor_id/
      VendorProfile vp;
      try {
        vp = VendorProfile::from_ini(update.target, true);
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1%, message: %2%", update.target, e.what());
        continue;
      }
      progress_dialog.Update(1, GUI::format_wxstr(_L("Downloading resources for %1%."),vp.id));
      progress_dialog.Pulse();
      for (const auto& model : vp.models) {
        for (const std::string& resource : { model.bed_texture, model.bed_model, model.thumbnail }) {
          if (resource.empty())
            continue;
          try
          {
            get_or_copy_missing_resource(vp.id, resource, vp.config_update_url);
          }
          catch (const std::exception& e)
          {
            BOOST_LOG_TRIVIAL(error) << "Failed to prepare " << resource << " for " << vp.id << " " << model.id << ": " << e.what();
          }
        }
      } 
    }
 
    progress_dialog.Destroy();
  }
 
  return true;
}

References _L, _u8L, Slic3r::VendorProfile::config_update_url, Slic3r::data_dir(), Slic3r::Disable, error, Slic3r::PresetBundle::filaments, Slic3r::PresetBundle::ObsoletePresets::filaments, Slic3r::format(), Slic3r::GUI::format_wxstr(), Slic3r::VendorProfile::from_ini(), Slic3r::VendorProfile::id, Slic3r::PresetBundle::load_configbundle(), Slic3r::PresetBundle::LoadSystem, Slic3r::VendorProfile::models, Slic3r::PresetBundle::obsolete_presets, Slic3r::PresetBundle::printers, Slic3r::PresetBundle::ObsoletePresets::printers, Slic3r::PresetBundle::prints, Slic3r::PresetBundle::ObsoletePresets::prints, Slic3r::PresetCollection::size(), Slic3r::PresetBundle::ObsoletePresets::sla_materials, Slic3r::PresetBundle::ObsoletePresets::sla_prints, Slic3r::GUI::Config::take_config_snapshot_cancel_on_error(), and updates.

Here is the call graph for this function:

prune_tmps()

void Slic3r::PresetUpdater::priv::prune_tmps

(

)

const

{
    for (auto &dir_entry : boost::filesystem::directory_iterator(cache_path))
    if (is_plain_file(dir_entry) && dir_entry.path().extension() == TMP_EXTENSION) {
      BOOST_LOG_TRIVIAL(debug) << "Cache prune: " << dir_entry.path().string();
      fs::remove(dir_entry.path());
    }
}

References Slic3r::is_plain_file(), and Slic3r::TMP_EXTENSION.

Here is the call graph for this function:

set_download_prefs()

void Slic3r::PresetUpdater::priv::set_download_prefs

(

const AppConfig *

app_config

)

{
  enabled_version_check = app_config->get("notify_release") != "none";
  version_check_url = app_config->version_check_url();
  enabled_config_update = app_config->get_bool("preset_update") && !app_config->legacy_datadir();
}

References Slic3r::AppConfig::get(), Slic3r::AppConfig::get_bool(), Slic3r::AppConfig::legacy_datadir(), and Slic3r::AppConfig::version_check_url().

Referenced by priv().

Here is the call graph for this function:

Here is the caller graph for this function:

set_waiting_updates()

void Slic3r::PresetUpdater::priv::set_waiting_updates

(

Updates

u

)

{
  waiting_updates = u;
  has_waiting_updates = true;
}

sync_config()

void Slic3r::PresetUpdater::priv::sync_config	(	const VendorMap	vendors,
		const std::string &	index_archive_url
	)

{
  BOOST_LOG_TRIVIAL(info) << "Syncing configuration cache";
 
  if (!enabled_config_update) { return; }
 
  // Download profiles archive zip
  // dk: Do we want to return here on error? Or skip archive dwnld and unzip and work with previous run state cache / vendor? I think return.
  // Any error here also doesnt show any info in UI. Do we want maybe notification?
  fs::path archive_path(cache_path / "vendor_indices.zip");
  if (index_archive_url.empty()) {
    BOOST_LOG_TRIVIAL(error) << "Downloading profile archive failed - url has no value.";
    return;
  }
  BOOST_LOG_TRIVIAL(info) << "Downloading vedor profiles archive zip from " << index_archive_url;
  //check if idx_url is leading to our site 
  if (!boost::starts_with(index_archive_url, "http://files.prusa3d.com/wp-content/uploads/repository/") &&
    !boost::starts_with(index_archive_url, "https://files.prusa3d.com/wp-content/uploads/repository/"))
  {
    BOOST_LOG_TRIVIAL(error) << "Unsafe url path for vedor profiles archive zip. Download is rejected.";
    return;
  }
  if (!get_file(index_archive_url, archive_path)) {
    BOOST_LOG_TRIVIAL(error) << "Download of vedor profiles archive zip failed.";
    return;
  }
  if (cancel) { 
    return; 
  }
 
  enum class VendorStatus
  {
    IN_ARCHIVE,
    IN_CACHE,
    NEW_VERSION,
    INSTALLED
  };
 
  std::vector<std::pair<std::string, VendorStatus>> vendors_with_status;
  // Unzip archive to cache / vendor
  mz_zip_archive archive;
  mz_zip_zero_struct(&archive);
  if (!open_zip_reader(&archive, archive_path.string())) {
    BOOST_LOG_TRIVIAL(error) << "Couldn't open zipped bundle.";
    return;
  } else {
    mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
    // loop the entries 
    mz_zip_archive_file_stat stat;
    for (mz_uint i = 0; i < num_entries; ++i) {
      if (mz_zip_reader_file_stat(&archive, i, &stat)) {
        std::string name(stat.m_filename);
        if (stat.m_uncomp_size > 0) {
          std::string buffer((size_t)stat.m_uncomp_size, 0);
          mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
          if (res == 0) {
            BOOST_LOG_TRIVIAL(error) << "Failed to unzip " << stat.m_filename;
            continue;
          }
          // create file from buffer
          fs::path tmp_path(cache_vendor_path / (name + ".tmp"));
          if (!fs::exists(tmp_path.parent_path())) {
            BOOST_LOG_TRIVIAL(error) << "Failed to unzip file " << name << ". Directories are not supported. Skipping file.";
            continue;
          }
          fs::path target_path(cache_vendor_path / name);
          fs::fstream file(tmp_path, std::ios::out | std::ios::binary | std::ios::trunc);
          file.write(buffer.c_str(), buffer.size());
          file.close();
          boost::system::error_code ec;
          bool exists = fs::exists(tmp_path, ec);
          if(!exists || ec) {
            BOOST_LOG_TRIVIAL(error) << "Failed to find unzipped file at " << tmp_path << ". Terminating Preset updater synchorinzation." ;
            close_zip_reader(&archive);
            return;
          }
          fs::rename(tmp_path, target_path, ec);
          if (ec) {
            BOOST_LOG_TRIVIAL(error) << "Failed to rename unzipped file at " << tmp_path << ". Terminating Preset updater synchorinzation. Error message: " << ec.message();
            close_zip_reader(&archive);
            return;
          }
          // TODO: what if unexpected happens here (folder inside zip) - crash! 
 
          if (name.substr(name.size() - 3) == "idx")
            vendors_with_status.emplace_back(name.substr(0, name.size() - 4), VendorStatus::IN_ARCHIVE); // asume for now its only in archive - if not, it will change later.
        }
      }
    }
    close_zip_reader(&archive);
  }
 
  // Update vendor preset bundles if in Vendor
  // Over all indices from the cache directory:
  for (auto &index : index_db) {
    if (cancel) { 
      return; 
    }
    auto archive_it = std::find_if(vendors_with_status.begin(), vendors_with_status.end(),
      [&index](const std::pair<std::string, VendorStatus>& element) { return element.first == index.vendor(); });
    //assert(archive_it != vendors_with_status.end()); // this would mean there is a index for vendor that is missing in recently downloaded archive
 
    const auto vendor_it = vendors.find(index.vendor());
    if (vendor_it == vendors.end()) {
      // Not installed vendor yet we need to check missing thumbnails (of new printers)
      BOOST_LOG_TRIVIAL(debug) << "No such vendor: " << index.vendor();
      if (archive_it != vendors_with_status.end())
        archive_it->second = VendorStatus::IN_CACHE;
      continue;
    }
 
    if (archive_it != vendors_with_status.end())
      archive_it->second = VendorStatus::INSTALLED;
 
    const VendorProfile &vendor = vendor_it->second;
    const std::string idx_path = (cache_path / (vendor.id + ".idx")).string();
    const std::string idx_path_temp = (cache_vendor_path / (vendor.id + ".idx")).string();
    
    // Load the fresh index up
    {
      Index new_index;
      try {
        new_index.load(idx_path_temp);
      } catch (const std::exception & /* err */) {
        BOOST_LOG_TRIVIAL(error) << format("Could not load downloaded index %1% for vendor %2%: invalid index?", idx_path_temp, vendor.name);
        continue;
      }
      if (new_index.version() < index.version()) {
        BOOST_LOG_TRIVIAL(info) << format("The downloaded index %1% for vendor %2% is older than the active one. Ignoring the downloaded index.", idx_path_temp, vendor.name);
        continue;
      }
      copy_file_fix(idx_path_temp, idx_path);
      
      //if we rename path we need to change it in Index object too or create the object again
      //index = std::move(new_index);
      try {
        index.load(idx_path);
      }
      catch (const std::exception& /* err */) {
        BOOST_LOG_TRIVIAL(error) << format("Could not load downloaded index %1% for vendor %2%: invalid index?", idx_path, vendor.name);
        continue;
      }
      if (cancel)
        return;
    }
 
    // See if a there's a new version to download
    const auto recommended_it = index.recommended();
    if (recommended_it == index.end()) {
      BOOST_LOG_TRIVIAL(error) << format("No recommended version for vendor: %1%, invalid index?", vendor.name);
      continue;
    }
 
    const auto recommended = recommended_it->config_version;
 
    BOOST_LOG_TRIVIAL(debug) << format("Got index for vendor: %1%: current version: %2%, recommended version: %3%",
      vendor.name,
      vendor.config_version.to_string(),
      recommended.to_string());
 
    if (vendor.config_version >= recommended) { continue; }
 
    // vendors that are checked here, doesnt need to be checked again later
    if (archive_it != vendors_with_status.end())
      archive_it->second = VendorStatus::NEW_VERSION;
 
    // Download recomended ini to cache
    const auto path_in_cache = cache_path / (vendor.id + ".ini");
    BOOST_LOG_TRIVIAL(info) << "Downloading new bundle for vendor: " << vendor.name;
    const auto bundle_url = format("%1%/%2%.ini", vendor.config_update_url, recommended.to_string());
    const auto bundle_path = cache_path / (vendor.id + ".ini");
    if (!get_file(bundle_url, bundle_path))
      continue;
    if (cancel)
      return;
    // vp is fully loaded to get all resources
    VendorProfile vp;
    try {
      vp = VendorProfile::from_ini(bundle_path, true);
    } catch (const std::exception& e) {
      BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.id, bundle_path, e.what());
      continue;
    }
    // check the fresh bundle for missing resources
    // for that, the ini file must be parsed (done above)
    for (const auto& model : vp.models) {
      for (const std::string& res : { model.bed_texture, model.bed_model, model.thumbnail/*id +"_thumbnail.png"*/} ) {
        if (! res.empty()) {
          try
          {
            get_missing_resource(vp.id, res, vendor.config_update_url);
          }
          catch (const std::exception& e)
          {
            BOOST_LOG_TRIVIAL(error) << "Failed to get " << res << " for " << vp.id << " " << model.id << ": " << e.what();
          }
          
        }
        if (cancel)
            return;
      }
    }
  }
  // Download missing thumbnails for not-installed vendors.
  //for (const std::string& vendor : vendors_only_in_archive) 
  for (const std::pair<std::string, VendorStatus >& vendor :  vendors_with_status) {
    if (vendor.second == VendorStatus::IN_ARCHIVE) {
      // index in archive and not in cache and not installed vendor
      
      const auto idx_path_in_archive = cache_vendor_path / (vendor.first + ".idx");
      const auto ini_path_in_archive = cache_vendor_path / (vendor.first + ".ini");
      if (!fs::exists(idx_path_in_archive))
        continue;
      Index index;
      try {
        index.load(idx_path_in_archive);
      }
      catch (const std::exception& /* err */) {
        BOOST_LOG_TRIVIAL(error) << format("Could not load downloaded index %1% for vendor %2%: invalid index?", idx_path_in_archive, vendor.first);
        continue;
      }
      const auto recommended_it = index.recommended();
      if (recommended_it == index.end()) {
        BOOST_LOG_TRIVIAL(error) << format("No recommended version for vendor: %1%, invalid index? (%2%)", vendor.first, idx_path_in_archive);
        continue;
      }
      const auto recommended = recommended_it->config_version;
      if (!fs::exists(ini_path_in_archive)){
        // Download recommneded to vendor - we do not have any existing ini file so we have to use hardcoded url.
        const std::string fixed_url = GUI::wxGetApp().app_config->profile_folder_url();
        const auto bundle_url = format("%1%/%2%/%3%.ini", fixed_url, vendor.first, recommended.to_string());
        if (!get_file(bundle_url, ini_path_in_archive))
          continue;
      } else {
        // check existing ini version
        // then download recommneded to vendor if needed
        VendorProfile vp;
        try {
          vp = VendorProfile::from_ini(ini_path_in_archive, true);
        } catch (const std::exception& e) {
          BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, ini_path_in_archive, e.what());
          continue;
        }
        if (vp.config_version != recommended) {
          const std::string fixed_url = GUI::wxGetApp().app_config->profile_folder_url();
          const auto bundle_url = format("%1%/%2%/%3%.ini", fixed_url, vendor.first, recommended.to_string());
          if (!get_file(bundle_url, ini_path_in_archive))
            continue;
        }
      }
      // check missing thumbnails
      VendorProfile vp;
      try {
        vp = VendorProfile::from_ini(ini_path_in_archive, true);
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, ini_path_in_archive, e.what());
        continue;
      }
      for (const auto& model : vp.models) {
        if (!model.thumbnail.empty()) {
          try
          {
            get_missing_resource(vp.id, model.thumbnail, vp.config_update_url);
          }
          catch (const std::exception& e)
          {
            BOOST_LOG_TRIVIAL(error) << "Failed to get " << model.thumbnail << " for " << vp.id << " " << model.id << ": " << e.what();
          }
        }
        if (cancel)
          return;
      }
    } else if (vendor.second == VendorStatus::IN_CACHE) {
      // find those where archive index recommends other version than index in cache and get it if not present
      const auto idx_path_in_archive = cache_vendor_path / (vendor.first + ".idx");
      const auto ini_path_in_archive = cache_vendor_path / (vendor.first + ".ini");
      const auto idx_path_in_cache = cache_path / (vendor.first + ".idx");
 
      if (!fs::exists(idx_path_in_archive) || !fs::exists(idx_path_in_cache))
          continue;
 
      // Compare index in cache and recetly downloaded one as part of zip archive
      Index index_cache;
      try {
        index_cache.load(idx_path_in_cache);
      }
      catch (const std::exception& /* err */) {
        BOOST_LOG_TRIVIAL(error) << format("Could not load downloaded index %1% for vendor %2%: invalid index?", idx_path_in_cache, vendor.first);
        continue;
      }
      const auto recommended_it_cache = index_cache.recommended();
      if (recommended_it_cache == index_cache.end()) {
        BOOST_LOG_TRIVIAL(error) << format("No recommended version for vendor: %1%, invalid index? (%2%)", vendor.first, idx_path_in_cache);
        continue;
      }
      const auto recommended_cache = recommended_it_cache->config_version;
 
      Index index_archive;
      try {
        index_archive.load(idx_path_in_archive);
      }
      catch (const std::exception& /* err */) {
        BOOST_LOG_TRIVIAL(error) << format("Could not load downloaded index %1% for vendor %2%: invalid index?", idx_path_in_archive, vendor.first);
        continue;
      }
      const auto recommended_it_archive = index_archive.recommended();
      if (recommended_it_archive == index_archive.end()) {
        BOOST_LOG_TRIVIAL(error) << format("No recommended version for vendor: %1%, invalid index? (%2%)", vendor.first, idx_path_in_archive);
        continue;
      }
      const auto recommended_archive = recommended_it_archive->config_version;
      
      if (recommended_archive <= recommended_cache) {
        // There isn't  more recent recomended version online. This vendor is also not istalled.
        // Thus only .ini is in resources and came with installation.
        // And we expect all resources are present.
        continue;
      }
      
      // Download new .ini if needed. So next time user runs Wizard, most recent profiles are shown & installed.
      if (!fs::exists(ini_path_in_archive) || fs::is_empty(ini_path_in_archive)) {
        // download recommneded to vendor 
        const fs::path ini_path_in_rsrc = rsrc_path / (vendor.first + ".ini");
        if (!fs::exists(ini_path_in_rsrc)) {
          // THIS SHOULD NOT HAPPEN
          continue;
        }
        // Get download path from existing ini.
        VendorProfile vp;
        try {
          vp = VendorProfile::from_ini(ini_path_in_rsrc, false);
        }
        catch (const std::exception& e) {
          BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, ini_path_in_rsrc, e.what());
          continue;
        }
        const auto bundle_url = format("%1%/%2%.ini", vp.config_update_url, recommended_archive.to_string());
        if (!get_file(bundle_url, ini_path_in_archive)) {
          BOOST_LOG_TRIVIAL(error) << format("Failed to open vendor .ini file when checking missing resources: %1%", ini_path_in_rsrc);
          continue;
        }
      } else {
        // Check existing ini version.
        // Then download recommneded to vendor if needed.
        VendorProfile vp;
        try {
          vp = VendorProfile::from_ini(ini_path_in_archive, false);
        }
        catch (const std::exception& e) {
          BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, ini_path_in_archive, e.what());
          continue;
        }
        if (vp.config_version != recommended_archive) {
          const auto bundle_url = format("%1%/%2%.ini", vp.config_update_url, recommended_archive.to_string());
          if (!get_file(bundle_url, ini_path_in_archive)) {
            BOOST_LOG_TRIVIAL(error) << format("Failed to open vendor .ini file when checking missing resources: %1%", ini_path_in_archive);
            continue;
          }
        }
      }
 
      if (!fs::exists(ini_path_in_archive)) {
        BOOST_LOG_TRIVIAL(error) << "Resources check failed to find ini file for vendor: " << vendor.first;
        continue;
      }
      // check missing thumbnails
      VendorProfile vp;
      try {
        vp = VendorProfile::from_ini(ini_path_in_archive, true);
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, ini_path_in_archive, e.what());
        continue;
      }
      for (const auto& model : vp.models) {
        if (!model.thumbnail.empty()) {
          try
          {
            get_missing_resource(vp.id, model.thumbnail, vp.config_update_url);
          }
          catch (const std::exception& e)
          {
            BOOST_LOG_TRIVIAL(error) << "Failed to get " << model.thumbnail << " for " << vp.id << " " << model.id << ": " << e.what();
          }
        }
        if (cancel)
          return;
      }
    } else if (vendor.second == VendorStatus::INSTALLED || vendor.second == VendorStatus::NEW_VERSION) {
      // Installed vendors need to check that no resource is missing. Do this only for files in vendor folder (not in resorces)
      // VendorStatus::NEW_VERSION might seem like a mistake here since files are downloaded when preparing update higher in this function. 
      // But this is a check for ini file in vendor where resources might be still missing since last update.
      const auto path_in_vendor = vendor_path / (vendor.first + ".ini");
      if(!fs::exists(path_in_vendor))
        continue;
      VendorProfile vp;
      try {
        vp = VendorProfile::from_ini(path_in_vendor, true);
      }
      catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << format("Corrupted profile file for vendor %1% at %2%, message: %3%", vendor.first, path_in_vendor, e.what());
        continue;
      }
      for (const auto& model : vp.models) {
        for (const std::string& res : { model.bed_texture, model.bed_model, model.thumbnail }) {
          if (!model.thumbnail.empty()) {
            try
            {
              get_or_copy_missing_resource(vp.id, res, vp.config_update_url);
            }
            catch (const std::exception& e)
            {
              BOOST_LOG_TRIVIAL(error) << "Failed to get " << model.thumbnail << " for " << vp.id << " " << model.id << ": " << e.what();
            }
          }
          if (cancel)
            return;
        }
      }
    }
  }
}

References Slic3r::close_zip_reader(), Slic3r::VendorProfile::config_update_url, Slic3r::VendorProfile::config_version, Slic3r::GUI::Config::Index::end(), error, exists(), Slic3r::format(), Slic3r::VendorProfile::from_ini(), Slic3r::VendorProfile::id, Slic3r::GUI::Config::Index::load(), Slic3r::VendorProfile::models, mz_zip_reader_extract_to_mem(), mz_zip_reader_file_stat(), mz_zip_reader_get_num_files(), mz_zip_zero_struct(), Slic3r::VendorProfile::name, Slic3r::open_zip_reader(), Slic3r::GUI::Config::Index::recommended(), stat, Slic3r::Semver::to_string(), and Slic3r::GUI::Config::Index::version().

Here is the call graph for this function:

update_index_db()

void Slic3r::PresetUpdater::priv::update_index_db

(

)

{
  index_db = Index::load_db();
}

Member Data Documentation

cache_path

fs::path Slic3r::PresetUpdater::priv::cache_path

cache_vendor_path

fs::path Slic3r::PresetUpdater::priv::cache_vendor_path

cancel

bool Slic3r::PresetUpdater::priv::cancel

enabled_config_update

bool Slic3r::PresetUpdater::priv::enabled_config_update

enabled_version_check

bool Slic3r::PresetUpdater::priv::enabled_version_check

has_waiting_updates

bool Slic3r::PresetUpdater::priv::has_waiting_updates { false }

index_db

std::vector<Index> Slic3r::PresetUpdater::priv::index_db

Referenced by priv().

rsrc_path

fs::path Slic3r::PresetUpdater::priv::rsrc_path

thread

std::thread Slic3r::PresetUpdater::priv::thread

vendor_path

fs::path Slic3r::PresetUpdater::priv::vendor_path

version_check_url

std::string Slic3r::PresetUpdater::priv::version_check_url

waiting_updates

Updates Slic3r::PresetUpdater::priv::waiting_updates

---

The documentation for this struct was generated from the following file:

• src/slic3r/Utils/PresetUpdater.cpp