Slic3r::GUI::FileGet::priv Struct Reference

Collaboration diagram for Slic3r::GUI::FileGet::priv:

Public Member Functions
	priv (int ID, std::string &&url, const std::string &filename, wxEvtHandler *evt_handler, const boost::filesystem::path &dest_folder)
void	get_perform ()

Public Attributes
const int	m_id
std::string	m_url
std::string	m_filename
std::thread	m_io_thread
wxEvtHandler *	m_evt_handler
boost::filesystem::path	m_dest_folder
boost::filesystem::path	m_tmp_path
std::atomic_bool	m_cancel { false }
std::atomic_bool	m_pause { false }
std::atomic_bool	m_stopped { false }
size_t	m_written { 0 }
size_t	m_absolute_size { 0 }

Detailed Description

Constructor & Destructor Documentation

priv()

Slic3r::GUI::FileGet::priv::priv	(	int	ID,
		std::string &&	url,
		const std::string &	filename,
		wxEvtHandler *	evt_handler,
		const boost::filesystem::path &	dest_folder )

  : m_id(ID)
  , m_url(std::move(url))
  , m_filename(filename)
  , m_evt_handler(evt_handler)
  , m_dest_folder(dest_folder)
{
}

References m_dest_folder, m_evt_handler, m_filename, m_id, and m_url.

Member Function Documentation

get_perform()

void Slic3r::GUI::FileGet::priv::get_perform

(

)

{
  assert(m_evt_handler);
  assert(!m_url.empty());
  assert(!m_filename.empty());
  assert(boost::filesystem::is_directory(m_dest_folder));
 
  m_stopped = false;
 
  // open dest file
  std::string extension;
  if (m_written == 0)
  {
    std::string final_filename;
    bool found = false;
    try {
      found = find_unused_filename(m_dest_folder, m_filename, m_tmp_path, final_filename);
    } catch (const boost::filesystem::filesystem_error& e)
    {
      wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
      evt->SetString(e.what());
      evt->SetInt(m_id);
      m_evt_handler->QueueEvent(evt);
      return;
    }
    if (!found) {
      wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
      evt->SetString(GUI::format_wxstr(_L("Failed to find suitable filename. Last name: %1%."), (m_dest_folder / final_filename).string()));
      evt->SetInt(m_id);
      m_evt_handler->QueueEvent(evt);
      return;
    }
 
        m_filename = final_filename;
    extension = boost::filesystem::path(m_filename).extension().string();
 
        m_tmp_path = download_marker_path(m_dest_folder, m_filename);
 
    wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_NAME_CHANGE);
    evt->SetString(boost::nowide::widen(m_filename));
    evt->SetInt(m_id);
    m_evt_handler->QueueEvent(evt);
  }
  
  boost::filesystem::path dest_path;
  if(!extension.empty())
    dest_path = m_dest_folder / m_filename;
 
  wxString temp_path_wstring(m_tmp_path.wstring());
  
  //std::cout << "dest_path: " << dest_path.string() << std::endl;
  //std::cout << "m_tmp_path: " << m_tmp_path.string() << std::endl;
  
  BOOST_LOG_TRIVIAL(info) << GUI::format("Starting download from %1% to %2%. Temp path is %3%",m_url, dest_path, m_tmp_path);
 
  FILE* file;
  // open file for writting
  if (m_written == 0)
    file = fopen(temp_path_wstring.c_str(), "wb");
  else 
    file = fopen(temp_path_wstring.c_str(), "ab");
 
  //assert(file != NULL);
  if (file == NULL) {
    wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
    // TRN %1% = file path
    evt->SetString(GUI::format_wxstr(_L("Can't create file at %1%"), temp_path_wstring));
    evt->SetInt(m_id);
    m_evt_handler->QueueEvent(evt);
    return;
  }
 
    std:: string range_string = std::to_string(m_written) + "-";
 
    size_t written_previously = m_written;
    size_t written_this_session = 0;
    Http::get(m_url)
      .size_limit(DOWNLOAD_SIZE_LIMIT) //more?
    .set_range(range_string)
    .on_header_callback([&](std::string header) {
      if(dest_path.empty()) {
        std::string filename = extract_remote_filename(header);
        if (!filename.empty()) {
          // The name comes from the server: keep it inside the destination folder and never
          // replace an existing file. Keep the current name if nothing usable remains.
          filename = sanitize_file_basename(filename);
          std::string unused;
          try {
            if (filename.empty() || !find_unused_filename(m_dest_folder, filename, m_tmp_path, unused))
              unused.clear();
          } catch (const boost::filesystem::filesystem_error&) {
            unused.clear();
          }
          const boost::filesystem::path tmp_path = unused.empty() ? m_tmp_path : download_marker_path(m_dest_folder, unused);
          if (tmp_path != m_tmp_path) {
            // Move the marker to the adopted name so that other downloads see the name as taken.
            // Only before anything is written, so that no downloaded data has to be carried over.
            FILE* tmp_file = m_written == 0 ? fopen(wxString(tmp_path.wstring()).c_str(), "wb") : nullptr;
            if (tmp_file != nullptr) {
              fclose(file);
              boost::system::error_code ec;
              boost::filesystem::remove(m_tmp_path, ec);
              file = tmp_file;
              m_tmp_path = tmp_path;
            } else
              unused.clear();
          }
          if (!unused.empty())
            m_filename = unused;
          dest_path = m_dest_folder / m_filename;
          wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_NAME_CHANGE);
          evt->SetString(boost::nowide::widen(m_filename));
          evt->SetInt(m_id);
          m_evt_handler->QueueEvent(evt);
        }
      }
    })
    .on_progress([&](Http::Progress progress, bool& cancel) {
      // to prevent multiple calls into following ifs (m_cancel / m_pause)
      if (m_stopped){
        cancel = true;
        return;
      }
      if (m_cancel) {
        m_stopped = true;
        fclose(file);
        // remove canceled file
        std::remove(m_tmp_path.string().c_str());
        m_written = 0;
        cancel = true;
        wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_CANCELED);
        evt->SetInt(m_id);
        m_evt_handler->QueueEvent(evt);
        return;
        // TODO: send canceled event?
      }   
      if (m_pause) {
        m_stopped = true;
        fclose(file);
        cancel = true;
        if (m_written == 0)
          std::remove(m_tmp_path.string().c_str());
        wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_PAUSED);
        evt->SetInt(m_id);
        m_evt_handler->QueueEvent(evt);
        return;
      }
      
      if (m_absolute_size < progress.dltotal) {
        m_absolute_size = progress.dltotal;
      }
 
      if (progress.dlnow != 0) {
      if (progress.dlnow - written_this_session > DOWNLOAD_MAX_CHUNK_SIZE || progress.dlnow == progress.dltotal) {
          try
          {
            std::string part_for_write = progress.buffer.substr(written_this_session, progress.dlnow);
            fwrite(part_for_write.c_str(), 1, part_for_write.size(), file);
          }
          catch (const std::exception& e)
          {
            // fclose(file); do it?
            wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
            evt->SetString(e.what());
            evt->SetInt(m_id);
            m_evt_handler->QueueEvent(evt);
            cancel = true;
            return;
          }
          written_this_session = progress.dlnow;
          m_written = written_previously + written_this_session;
        }
        wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_PROGRESS);
        int             percent_total = m_absolute_size == 0 ? 0 : (written_previously + progress.dlnow) * 100 / m_absolute_size;
        evt->SetString(std::to_string(percent_total));
        evt->SetInt(m_id);
        m_evt_handler->QueueEvent(evt);
      }
      
    })
    .on_error([&](std::string body, std::string error, unsigned http_status) {
      if (file != NULL)
        fclose(file);
      wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
      if (!error.empty())
        evt->SetString(GUI::from_u8(error));
      else
        evt->SetString(GUI::from_u8(body));
      evt->SetInt(m_id);
      m_evt_handler->QueueEvent(evt);
    })
    .on_complete([&](std::string body, unsigned /* http_status */) {
 
      // TODO: perform a body size check
      // 
      //size_t body_size = body.size();
      //if (body_size != expected_size) {
      //  return;
      //}
      try
      {
        // Orca: thingiverse need this
        if (m_written < body.size())
        {
          // this code should never be entered. As there should be on_progress call after last bit downloaded.
          std::string part_for_write = body.substr(m_written);
          fwrite(part_for_write.c_str(), 1, part_for_write.size(), file);
 
                    wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_PROGRESS);
                    evt->SetString(std::to_string(100));
                    evt->SetInt(m_id);
                    m_evt_handler->QueueEvent(evt);
                }
        fclose(file);
        // Another file may have taken the name while downloading.
        if (!dest_path.empty() && boost::filesystem::exists(dest_path)) {
          std::string unused;
          if (!find_unused_filename(m_dest_folder, m_filename, m_tmp_path, unused))
            throw std::runtime_error("No unused file name.");
          m_filename = unused;
          dest_path = m_dest_folder / m_filename;
          wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_NAME_CHANGE);
          evt->SetString(boost::nowide::widen(m_filename));
          evt->SetInt(m_id);
          m_evt_handler->QueueEvent(evt);
        }
        boost::filesystem::rename(m_tmp_path, dest_path);
      }
      catch (const std::exception& /*e*/)
      {
        //TODO: report?
        //error_message = GUI::format("Failed to write and move %1% to %2%", tmp_path, dest_path);
        wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_ERROR);
        evt->SetString(_L("Failed to write and move."));
        evt->SetInt(m_id);
        m_evt_handler->QueueEvent(evt);
        return;
      }
 
      wxCommandEvent* evt = new wxCommandEvent(EVT_DWNLDR_FILE_COMPLETE);
      evt->SetString(dest_path.wstring());
      evt->SetInt(m_id);
      m_evt_handler->QueueEvent(evt);
    })
    .perform_sync();
 
}

References _L, Slic3r::Http::Progress::buffer, Slic3r::GUI::FileGet::cancel(), Slic3r::Http::Progress::dlnow, Slic3r::Http::Progress::dltotal, Slic3r::download_marker_path(), Slic3r::GUI::DOWNLOAD_MAX_CHUNK_SIZE, Slic3r::GUI::DOWNLOAD_SIZE_LIMIT, Slic3r::GUI::extract_remote_filename(), Slic3r::find_unused_filename(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), m_absolute_size, m_cancel, m_dest_folder, m_evt_handler, m_filename, m_id, m_pause, m_stopped, m_tmp_path, m_url, m_written, Slic3r::Http::on_header_callback(), Slic3r::sanitize_file_basename(), Slic3r::Http::set_range(), and Slic3r::Http::size_limit().

Here is the call graph for this function:

Member Data Documentation

m_absolute_size

size_t Slic3r::GUI::FileGet::priv::m_absolute_size { 0 }

{ 0 };

Referenced by get_perform().

m_cancel

std::atomic_bool Slic3r::GUI::FileGet::priv::m_cancel { false }

{ false };

Referenced by get_perform().

m_dest_folder

boost::filesystem::path Slic3r::GUI::FileGet::priv::m_dest_folder

Referenced by priv(), and get_perform().

m_evt_handler

wxEvtHandler* Slic3r::GUI::FileGet::priv::m_evt_handler

Referenced by priv(), and get_perform().

m_filename

std::string Slic3r::GUI::FileGet::priv::m_filename

Referenced by priv(), and get_perform().

m_id

const int Slic3r::GUI::FileGet::priv::m_id

Referenced by priv(), and get_perform().

m_io_thread

std::thread Slic3r::GUI::FileGet::priv::m_io_thread

m_pause

std::atomic_bool Slic3r::GUI::FileGet::priv::m_pause { false }

{ false };

Referenced by get_perform().

m_stopped

std::atomic_bool Slic3r::GUI::FileGet::priv::m_stopped { false }

{ false }; // either canceled or paused - download is not running

Referenced by get_perform().

m_tmp_path

boost::filesystem::path Slic3r::GUI::FileGet::priv::m_tmp_path

Referenced by get_perform().

m_url

std::string Slic3r::GUI::FileGet::priv::m_url

Referenced by priv(), and get_perform().

m_written

size_t Slic3r::GUI::FileGet::priv::m_written { 0 }

{ 0 };

Referenced by get_perform().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DownloaderFileGet.cpp