Slic3r::AppUpdater::priv Struct Reference

Collaboration diagram for Slic3r::AppUpdater::priv:

Public Member Functions
	priv ()
bool	http_get_file (const std::string &url, size_t size_limit, std::function< bool(Http::Progress)> progress_fn, std::function< bool(std::string, std::string &error_message)> completefn, std::string &error_message) const
boost::filesystem::path	download_file (const DownloadAppData &data) const
bool	run_downloaded_file (boost::filesystem::path path)
void	version_check (const std::string &version_check_url)
void	parse_version_string (const std::string &body)
bool	get_download_ongoing () const
DownloadAppData	get_app_data ()
void	set_app_data (DownloadAppData data)
bool	get_triggered_by_user () const

Public Attributes
std::thread	m_thread
std::atomic_bool	m_cancel
std::mutex	m_data_mutex
std::atomic_bool	m_download_ongoing { false }
boost::filesystem::path	m_default_dest_folder
DownloadAppData	m_online_version_data
std::atomic_bool	m_triggered_by_user {false}

Detailed Description

Constructor & Destructor Documentation

priv()

Slic3r::AppUpdater::priv::priv

(

)

                     :
  m_cancel (false)
#ifdef __linux__
    , m_default_dest_folder (boost::filesystem::path("/tmp"))
#else
  , m_default_dest_folder (boost::filesystem::path(data_dir()) / "cache")
#endif //_WIN32
{ 
  boost::filesystem::path downloads_path = boost::filesystem::path(get_downloads_path());
  if (!downloads_path.empty()) {
    m_default_dest_folder = std::move(downloads_path);
  }
  BOOST_LOG_TRIVIAL(trace) << "App updater default download path: " << m_default_dest_folder; //lm:Is this an error? // dk: changed to trace
  
}

References m_default_dest_folder.

Member Function Documentation

download_file()

boost::filesystem::path Slic3r::AppUpdater::priv::download_file

(

const DownloadAppData &

data

)

const

{
  boost::filesystem::path dest_path;
  size_t last_gui_progress = 0;
  size_t expected_size = data.size;
  dest_path = data.target_path;
  assert(!dest_path.empty());
  if (dest_path.empty())
  {
    std::string line1 = GUI::format(_u8L("Internal download error for url %1%:"), data.url);
    std::string line2 = _u8L("Destination path is empty.");
    std::string message = GUI::format("%1%\n%2%", line1, line2);
    BOOST_LOG_TRIVIAL(error) << message;
    wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED);
    evt->SetString(message);
    GUI::wxGetApp().QueueEvent(evt);
    return boost::filesystem::path();
  }
 
  boost::filesystem::path tmp_path = dest_path;
  tmp_path += format(".%1%%2%", std::to_string(GUI::GLCanvas3D::timestamp_now()), ".download");
  FILE* file;
  wxString temp_path_wstring(tmp_path.wstring());
  file = fopen(temp_path_wstring.c_str(), "wb");
  assert(file != NULL);
  if (file == NULL) {
      std::string line1 = GUI::format(_u8L("Download from %1% couldn't start:"), data.url);
    std::string line2 = GUI::format(_u8L("Can't create file at %1%"), tmp_path.string());
    std::string message = GUI::format("%1%\n%2%", line1, line2);
    BOOST_LOG_TRIVIAL(error) << message;
    wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED);
    evt->SetString(message);
    GUI::wxGetApp().QueueEvent(evt);
    return boost::filesystem::path();
  }
 
  std::string error_message;
  bool res = http_get_file(data.url, 130 * 1024 * 1024 //2.4.0 windows installer is 65MB //lm:I don't know, but larger. The binaries will grow. // dk: changed to 130, to have 100% more space. We should put this information into version file. 
    // on_progress
    , [&last_gui_progress, expected_size](Http::Progress progress) {
      // size check
      if (progress.dltotal > 0 && progress.dltotal > expected_size) {
        std::string message = GUI::format("Downloading new %1% has failed. The file has incorrect file size. Aborting download.\nExpected size: %2%\nDownload size: %3%", SLIC3R_APP_NAME, expected_size, progress.dltotal);
        BOOST_LOG_TRIVIAL(error) << message;
        wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED);
        evt->SetString(message);
        GUI::wxGetApp().QueueEvent(evt);
        return false;
      } else if (progress.dltotal > 0 && progress.dltotal < expected_size) { 
        // This is possible error, but we cannot know until the download is finished. Somehow the total size can grow during the download.
        BOOST_LOG_TRIVIAL(info) << GUI::format("Downloading new %1% has incorrect size. The download will continue. \nExpected size: %2%\nDownload size: %3%", SLIC3R_APP_NAME, expected_size, progress.dltotal);
      } 
      // progress event
      size_t gui_progress = progress.dltotal > 0 ? 100 * progress.dlnow / progress.dltotal : 0;
      BOOST_LOG_TRIVIAL(debug) << "App download " << gui_progress << "% " << progress.dlnow << " of " << progress.dltotal;
      if (last_gui_progress < gui_progress && (last_gui_progress != 0 || gui_progress != 100)) {
        last_gui_progress = gui_progress;
        wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_PROGRESS);
        evt->SetString(GUI::from_u8(std::to_string(gui_progress)));
        GUI::wxGetApp().QueueEvent(evt);
      }
      return true;
    }
    // on_complete
    , [&file, dest_path, tmp_path, expected_size](std::string body, std::string& error_message){
      // Size check. Does always 1 char == 1 byte?
      size_t body_size = body.size(); 
      if (body_size != expected_size) {
        error_message = GUI::format(_u8L("Downloaded file has wrong size. Expected size: %1% Downloaded size: %2%"), expected_size, body_size);
        return false;
      }
      if (file == NULL) {
        error_message = GUI::format(_u8L("Can't create file at %1%"), tmp_path.string());
        return false;
      }
      try
      {
        fwrite(body.c_str(), 1, body.size(), file);
        fclose(file);
        boost::filesystem::rename(tmp_path, dest_path);
      }
      catch (const std::exception& e)
      {
        error_message = GUI::format(_u8L("Failed to write to file or to move %1% to %2%:\n%3%"), tmp_path, dest_path, e.what());
        return false;
      }
      return true;
    }
    , error_message
  );
  if (!res)
  {
    if (m_cancel) {
      BOOST_LOG_TRIVIAL(info) << error_message; 
      wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED); // FAILED with empty msg only closes progress notification
      GUI::wxGetApp().QueueEvent(evt);
    } else {
      std::string message = (error_message.empty() 
        ? std::string()
        : GUI::format(_u8L("Downloading new %1% has failed:\n%2%"), SLIC3R_APP_NAME, error_message));
      wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED);
      if (!message.empty()) {
        BOOST_LOG_TRIVIAL(error) << message;
        evt->SetString(message);
      }
      GUI::wxGetApp().QueueEvent(evt);
    }
    return boost::filesystem::path();
  }
  
  return dest_path;
}

References _u8L, Slic3r::Http::Progress::dlnow, Slic3r::Http::Progress::dltotal, error, Slic3r::format(), Slic3r::GUI::format(), Slic3r::GUI::from_u8(), if(), and Slic3r::GUI::GLCanvas3D::timestamp_now().

Here is the call graph for this function:

get_app_data()

DownloadAppData Slic3r::AppUpdater::priv::get_app_data

(

)

{
  const std::lock_guard<std::mutex> lock(m_data_mutex);
  DownloadAppData ret_val(m_online_version_data);
  return ret_val;
}

get_download_ongoing()

bool Slic3r::AppUpdater::priv::get_download_ongoing ( ) const

inline

{ return m_download_ongoing; }

References m_download_ongoing.

get_triggered_by_user()

bool Slic3r::AppUpdater::priv::get_triggered_by_user ( ) const

inline

{ return m_triggered_by_user; }

References m_triggered_by_user.

http_get_file()

bool Slic3r::AppUpdater::priv::http_get_file	(	const std::string &	url,
		size_t	size_limit,
		std::function< bool(Http::Progress)>	progress_fn,
		std::function< bool(std::string, std::string &error_message)>	completefn,
		std::string &	error_message
	)		const

{
  bool res = false;
  Http::get(url)
    .size_limit(size_limit)
    .on_progress([&, progress_fn](Http::Progress progress, bool& cancel) {
      // progress function returns true as success (to continue) 
      cancel = (m_cancel ? true : !progress_fn(std::move(progress)));
      if (cancel) {
        // Lets keep error_message empty here - if there is need to show error dialog, the message will be probably shown by whatever caused the cancel.
        //error_message = GUI::format(_u8L("Error getting: `%1%`: Download was canceled."), url);
        BOOST_LOG_TRIVIAL(debug) << "AppUpdater::priv::http_get_file message: "<< error_message;
      }
    })
    .on_error([&](std::string body, std::string error, unsigned http_status) {
      error_message = GUI::format("Error getting: `%1%`: HTTP %2%, %3%",
        url,
        http_status,
        error);
      BOOST_LOG_TRIVIAL(error) << error_message;
    })
    .on_complete([&](std::string body, unsigned /* http_status */) {
      assert(complete_fn != nullptr);
      res = complete_fn(body, error_message);
    })
    .perform_sync();
  
  return res;
}

References Slic3r::AppUpdater::cancel(), error, Slic3r::GUI::format(), Slic3r::Http::get(), Slic3r::Http::on_progress(), and Slic3r::Http::size_limit().

Here is the call graph for this function:

parse_version_string()

void Slic3r::AppUpdater::priv::parse_version_string

(

const std::string &

body

)

{
  size_t start = body.find('[');
  if (start == std::string::npos) {
#if 0
    BOOST_LOG_TRIVIAL(error) << "Could not find property tree in version file. Starting old parsing.";
    parse_version_string_old(body);
    return;
#endif // 0
    BOOST_LOG_TRIVIAL(error) << "Could not find property tree in version file. Checking for application update has failed.";
    // Lets send event with current version, this way if user triggered this check, it will notify him about no new version online.
    std::string version = Semver().to_string();
    wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_VERSION_ONLINE);
    evt->SetString(GUI::from_u8(version));
    GUI::wxGetApp().QueueEvent(evt);
    return;
  }
  std::string tree_string = body.substr(start);
  boost::property_tree::ptree tree;
  std::stringstream ss(tree_string);
  try {
    boost::property_tree::read_ini(ss, tree);
  } catch (const boost::property_tree::ini_parser::ini_parser_error& err) {
    //throw Slic3r::RuntimeError(format("Failed reading version file property tree Error: \"%1%\" at line %2%. \nTree:\n%3%", err.message(), err.line(), tree_string).c_str());
    BOOST_LOG_TRIVIAL(error) << format("Failed reading version file property tree Error: \"%1%\" at line %2%. \nTree:\n%3%", err.message(), err.line(), tree_string);
    return;
  }
 
  DownloadAppData new_data;
 
  for (const auto& section : tree) {
    std::string section_name = section.first;
 
    // online release version info
    if (section_name == 
#ifdef _WIN32
      "release:win64"
#elif __APPLE__
      "release:osx"
#else
      "release:linux"
#endif
//lm:Related to the ifdefs. We should also support BSD, which behaves similar to Linux in most cases.
// Unless you have a reason not to, I would consider doing _WIN32, elif __APPLE__, else ... Not just here.
// dk: so its ok now or we need to specify BSD?
      ) {
      for (const auto& data : section.second) {
        if (data.first == "url") {
          new_data.url = data.second.data();
          new_data.target_path = m_default_dest_folder / AppUpdater::get_filename_from_url(new_data.url);
          BOOST_LOG_TRIVIAL(info) << format("parsing version string: url: %1%", new_data.url);
        } else if (data.first == "size"){
          new_data.size = std::stoi(data.second.data());
          BOOST_LOG_TRIVIAL(info) << format("parsing version string: expected size: %1%", new_data.size);
        }
      }
    }
 
    // released versions - to be send to UI layer
    if (section_name == "common") {
      std::vector<std::string> prerelease_versions;
      for (const auto& data : section.second) {
        // release version - save and send to UI layer
        if (data.first == "release") {
          std::string version = data.second.data();
          boost::optional<Semver> release_version = Semver::parse(version);
          if (!release_version) {
            BOOST_LOG_TRIVIAL(error) << format("Received invalid contents from version file: Not a correct semver: `%1%`", version);
            return;
          }
          new_data.version = release_version;
          // Send after all data is read
          /*
          BOOST_LOG_TRIVIAL(info) << format("Got %1% online version: `%2%`. Sending to GUI thread...", SLIC3R_APP_NAME, version);
          wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_VERSION_ONLINE);
          evt->SetString(GUI::from_u8(version));
          GUI::wxGetApp().QueueEvent(evt);
          */
        // prerelease versions - write down to be sorted and send to UI layer
        } else if (data.first == "alpha") {
          prerelease_versions.emplace_back(data.second.data());
        } else if (data.first == "beta") {
          prerelease_versions.emplace_back(data.second.data());
        } else if (data.first == "rc") {
          prerelease_versions.emplace_back(data.second.data());
        }
      }
      // find recent version that is newer than last full release.
      boost::optional<Semver> recent_version;
      std::string       version_string;
      for (const std::string& ver_string : prerelease_versions) {
        boost::optional<Semver> ver = Semver::parse(ver_string);
        if (ver && *new_data.version < *ver && ((recent_version && *recent_version < *ver) || !recent_version)) {
          recent_version = ver;
          version_string = ver_string;
        }
      }
      // send prerelease version to UI layer
      if (recent_version) {
        BOOST_LOG_TRIVIAL(info) << format("Got %1% online version: `%2%`. Sending to GUI thread...", SLIC3R_APP_NAME, version_string);
        wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_EXPERIMENTAL_VERSION_ONLINE);
        evt->SetString(GUI::from_u8(version_string));
        GUI::wxGetApp().QueueEvent(evt);
      }
    }
  }
  assert(!new_data.url.empty());
  assert(new_data.version);
  // save
  set_app_data(new_data);
  // send
  std::string version = new_data.version.get().to_string();
  BOOST_LOG_TRIVIAL(info) << format("Got %1% online version: `%2%`. Sending to GUI thread...", SLIC3R_APP_NAME, version);
  wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_VERSION_ONLINE);
  evt->SetString(GUI::from_u8(version));
  GUI::wxGetApp().QueueEvent(evt);
}

References error, Slic3r::format(), Slic3r::GUI::from_u8(), Slic3r::AppUpdater::get_filename_from_url(), Slic3r::Semver::parse(), Slic3r::AppUpdater::set_app_data(), Slic3r::DownloadAppData::size, Slic3r::DownloadAppData::target_path, Slic3r::Semver::to_string(), Slic3r::DownloadAppData::url, version, and Slic3r::DownloadAppData::version.

Here is the call graph for this function:

run_downloaded_file()

bool Slic3r::AppUpdater::priv::run_downloaded_file

(

boost::filesystem::path

path

)

{
  assert(!path.empty());
  return run_file(path);
}

set_app_data()

void Slic3r::AppUpdater::priv::set_app_data

(

DownloadAppData

data

)

{
  const std::lock_guard<std::mutex> lock(m_data_mutex);
  m_online_version_data = data;
}

version_check()

void Slic3r::AppUpdater::priv::version_check

(

const std::string &

version_check_url

)

{
  assert(!version_check_url.empty());
  std::string error_message;
  bool res = http_get_file(version_check_url, 1024
    // on_progress
    , [](Http::Progress progress) { return true; }
    // on_complete
    , [&](std::string body, std::string& error_message) {
      boost::trim(body);
      parse_version_string(body);
      return true;
    }
    , error_message
  );
  //lm:In case the internet is not available, it will report no updates if run by user.
  // We might save a flag that we don't know or try to run the version_check again, reporting
  // the failure.
  // dk: changed to download version every time. Dialog will show if m_triggered_by_user.
  if (!res) {
    std::string message = GUI::format("Downloading %1% version file has failed:\n%2%", SLIC3R_APP_NAME, error_message);
    BOOST_LOG_TRIVIAL(error) << message;
    if (m_triggered_by_user) {
      wxCommandEvent* evt = new wxCommandEvent(EVT_SLIC3R_APP_DOWNLOAD_FAILED);
      evt->SetString(message);
      GUI::wxGetApp().QueueEvent(evt);
    }
  }
}

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

Here is the call graph for this function:

Member Data Documentation

m_cancel

std::atomic_bool Slic3r::AppUpdater::priv::m_cancel

m_data_mutex

std::mutex Slic3r::AppUpdater::priv::m_data_mutex

m_default_dest_folder

boost::filesystem::path Slic3r::AppUpdater::priv::m_default_dest_folder

Referenced by priv().

m_download_ongoing

std::atomic_bool Slic3r::AppUpdater::priv::m_download_ongoing { false }

Referenced by get_download_ongoing().

m_online_version_data

DownloadAppData Slic3r::AppUpdater::priv::m_online_version_data

m_thread

std::thread Slic3r::AppUpdater::priv::m_thread

m_triggered_by_user

std::atomic_bool Slic3r::AppUpdater::priv::m_triggered_by_user {false}

Referenced by get_triggered_by_user().

---

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

• src/slic3r/Utils/AppUpdater.cpp