*/
#include "clientmedia.h"
-#include "util/serialize.h"
-#include "util/sha1.h"
-#include "util/string.h"
#include "httpfetch.h"
#include "client.h"
-#include "network/networkprotocol.h"
#include "filecache.h"
#include "filesys.h"
-#include "hex.h"
-#include "debug.h"
#include "log.h"
#include "porting.h"
#include "settings.h"
-#include "main.h"
+#include "util/hex.h"
+#include "util/serialize.h"
+#include "util/sha1.h"
+#include "util/string.h"
static std::string getMediaCacheDir()
{
- return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media";
+ return porting::path_cache + DIR_DELIM + "media";
}
/*
*/
ClientMediaDownloader::ClientMediaDownloader():
- m_media_cache(getMediaCacheDir())
+ m_media_cache(getMediaCacheDir()),
+ m_httpfetch_caller(HTTPFETCH_DISCARD)
{
- m_initial_step_done = false;
- m_name_bound = ""; // works because "" is an invalid file name
- m_uncached_count = 0;
- m_uncached_received_count = 0;
- m_httpfetch_caller = HTTPFETCH_DISCARD;
- m_httpfetch_active = 0;
- m_httpfetch_active_limit = 0;
- m_httpfetch_next_id = 0;
- m_httpfetch_timeout = 0;
- m_outstanding_hash_sets = 0;
}
ClientMediaDownloader::~ClientMediaDownloader()
if (m_httpfetch_caller != HTTPFETCH_DISCARD)
httpfetch_caller_free(m_httpfetch_caller);
- for (std::map<std::string, FileStatus*>::iterator it = m_files.begin();
- it != m_files.end(); ++it)
- delete it->second;
+ for (auto &file_it : m_files)
+ delete file_it.second;
- for (u32 i = 0; i < m_remotes.size(); ++i)
- delete m_remotes[i];
+ for (auto &remote : m_remotes)
+ delete remote;
}
-void ClientMediaDownloader::addFile(std::string name, std::string sha1)
+void ClientMediaDownloader::addFile(const std::string &name, const std::string &sha1)
{
- assert(!m_initial_step_done);
+ assert(!m_initial_step_done); // pre-condition
// if name was already announced, ignore the new announcement
if (m_files.count(name) != 0) {
return;
}
- FileStatus *filestatus = new FileStatus;
+ FileStatus *filestatus = new FileStatus();
filestatus->received = false;
filestatus->sha1 = sha1;
filestatus->current_remote = -1;
m_files.insert(std::make_pair(name, filestatus));
}
-void ClientMediaDownloader::addRemoteServer(std::string baseurl)
+void ClientMediaDownloader::addRemoteServer(const std::string &baseurl)
{
- assert(!m_initial_step_done);
+ assert(!m_initial_step_done); // pre-condition
#ifdef USE_CURL
infostream << "Client: Adding remote server \""
<< baseurl << "\" for media download" << std::endl;
- RemoteServerStatus *remote = new RemoteServerStatus;
+ RemoteServerStatus *remote = new RemoteServerStatus();
remote->baseurl = baseurl;
remote->active_count = 0;
remote->request_by_filename = false;
{
// Check media cache
m_uncached_count = m_files.size();
- for (std::map<std::string, FileStatus*>::iterator
- it = m_files.begin();
- it != m_files.end(); ++it) {
- std::string name = it->first;
- FileStatus *filestatus = it->second;
+ for (auto &file_it : m_files) {
+ std::string name = file_it.first;
+ FileStatus *filestatus = file_it.second;
const std::string &sha1 = filestatus->sha1;
std::ostringstream tmp_os(std::ios_base::binary);
fetch_request.timeout = m_httpfetch_timeout;
fetch_request.connect_timeout = m_httpfetch_timeout;
fetch_request.post_data = required_hash_set;
- fetch_request.extra_headers.push_back(
+ fetch_request.extra_headers.emplace_back(
"Content-Type: application/octet-stream");
httpfetch_async(fetch_request);
std::string name;
{
- std::map<unsigned long, std::string>::iterator it =
+ std::unordered_map<unsigned long, std::string>::iterator it =
m_remote_file_transfers.find(fetch_result.request_id);
assert(it != m_remote_file_transfers.end());
name = it->second;
m_remote_file_transfers.erase(it);
}
- assert(m_files.count(name) != 0);
+ sanity_check(m_files.count(name) != 0);
FileStatus *filestatus = m_files[name];
- assert(!filestatus->received);
- assert(filestatus->current_remote >= 0);
+ sanity_check(!filestatus->received);
+ sanity_check(filestatus->current_remote >= 0);
RemoteServerStatus *remote = m_remotes[filestatus->current_remote];
s32 ClientMediaDownloader::selectRemoteServer(FileStatus *filestatus)
{
+ // Pre-conditions
assert(filestatus != NULL);
assert(!filestatus->received);
assert(filestatus->current_remote < 0);
if (filestatus->available_remotes.empty())
return -1;
- else {
- // Of all servers that claim to provide the file (and haven't
- // been unsuccessfully tried before), find the one with the
- // smallest number of currently active transfers
-
- s32 best = 0;
- s32 best_remote_id = filestatus->available_remotes[best];
- s32 best_active_count = m_remotes[best_remote_id]->active_count;
-
- for (u32 i = 1; i < filestatus->available_remotes.size(); ++i) {
- s32 remote_id = filestatus->available_remotes[i];
- s32 active_count = m_remotes[remote_id]->active_count;
- if (active_count < best_active_count) {
- best = i;
- best_remote_id = remote_id;
- best_active_count = active_count;
- }
+
+ // Of all servers that claim to provide the file (and haven't
+ // been unsuccessfully tried before), find the one with the
+ // smallest number of currently active transfers
+
+ s32 best = 0;
+ s32 best_remote_id = filestatus->available_remotes[best];
+ s32 best_active_count = m_remotes[best_remote_id]->active_count;
+
+ for (u32 i = 1; i < filestatus->available_remotes.size(); ++i) {
+ s32 remote_id = filestatus->available_remotes[i];
+ s32 active_count = m_remotes[remote_id]->active_count;
+ if (active_count < best_active_count) {
+ best = i;
+ best_remote_id = remote_id;
+ best_active_count = active_count;
}
+ }
- filestatus->available_remotes.erase(
- filestatus->available_remotes.begin() + best);
+ filestatus->available_remotes.erase(
+ filestatus->available_remotes.begin() + best);
+
+ return best_remote_id;
- return best_remote_id;
- }
}
void ClientMediaDownloader::startRemoteMediaTransfers()
void ClientMediaDownloader::startConventionalTransfers(Client *client)
{
- assert(m_httpfetch_active == 0);
+ assert(m_httpfetch_active == 0); // pre-condition
if (m_uncached_received_count != m_uncached_count) {
// Some media files have not been received yet, use the
// conventional slow method (minetest protocol) to get them
- std::list<std::string> file_requests;
- for (std::map<std::string, FileStatus*>::iterator
- it = m_files.begin();
- it != m_files.end(); ++it) {
- if (!it->second->received)
- file_requests.push_back(it->first);
+ std::vector<std::string> file_requests;
+ for (auto &file : m_files) {
+ if (!file.second->received)
+ file_requests.push_back(file.first);
}
assert((s32) file_requests.size() ==
m_uncached_count - m_uncached_received_count);
it = m_files.begin();
it != m_files.end(); ++it) {
if (!it->second->received) {
- assert(it->second->sha1.size() == 20);
+ FATAL_ERROR_IF(it->second->sha1.size() != 20, "Invalid SHA1 size");
os << it->second->sha1;
}
}
projects / minetest.git / blobdiff