/**************************************************************************/ /* editor_file_server.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /**************************************************************************/ /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ #include "editor_file_server.h" #include "../editor_settings.h" #include "core/io/marshalls.h" #include "editor/editor_node.h" #include "editor/export/editor_export_platform.h" #define FILESYSTEM_PROTOCOL_VERSION 1 #define PASSWORD_LENGTH 32 #define MAX_FILE_BUFFER_SIZE 100 * 1024 * 1024 // 100mb max file buffer size (description of files to update, compressed). static void _add_file(String f, const uint64_t &p_modified_time, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) { f = f.replace_first("res://", ""); // remove res:// const uint64_t *cached_mt = cached_files.getptr(f); if (cached_mt && *cached_mt == p_modified_time) { // File is good, skip it. cached_files.erase(f); // Erase to mark this file as existing. Remaining files not added to files_to_send will be considered erased here, so they need to be erased in the client too. return; } files_to_send.insert(f, p_modified_time); } void EditorFileServer::_scan_files_changed(EditorFileSystemDirectory *efd, const Vector<String> &p_tags, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) { for (int i = 0; i < efd->get_file_count(); i++) { String f = efd->get_file_path(i); if (FileAccess::exists(f + ".import")) { // is imported, determine what to do // Todo the modified times of remapped files should most likely be kept in EditorFileSystem to speed this up in the future. Ref<ConfigFile> cf; cf.instantiate(); Error err = cf->load(f + ".import"); ERR_CONTINUE(err != OK); { uint64_t mt = FileAccess::get_modified_time(f + ".import"); _add_file(f + ".import", mt, files_to_send, cached_files); } if (!cf->has_section("remap")) { continue; } List<String> remaps; cf->get_section_keys("remap", &remaps); for (const String &remap : remaps) { if (remap == "path") { String remapped_path = cf->get_value("remap", remap); uint64_t mt = FileAccess::get_modified_time(remapped_path); _add_file(remapped_path, mt, files_to_send, cached_files); } else if (remap.begins_with("path.")) { String feature = remap.get_slice(".", 1); if (p_tags.find(feature) != -1) { String remapped_path = cf->get_value("remap", remap); uint64_t mt = FileAccess::get_modified_time(remapped_path); _add_file(remapped_path, mt, files_to_send, cached_files); } } } } else { uint64_t mt = efd->get_file_modified_time(i); _add_file(f, mt, files_to_send, cached_files); } } for (int i = 0; i < efd->get_subdir_count(); i++) { _scan_files_changed(efd->get_subdir(i), p_tags, files_to_send, cached_files); } } static void _add_custom_file(const String f, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) { if (!FileAccess::exists(f)) { return; } _add_file(f, FileAccess::get_modified_time(f), files_to_send, cached_files); } void EditorFileServer::poll() { if (!active) { return; } if (!server->is_connection_available()) { return; } Ref<StreamPeerTCP> tcp_peer = server->take_connection(); ERR_FAIL_COND(tcp_peer.is_null()); // Got a connection! EditorProgress pr("updating_remote_file_system", TTR("Updating assets on target device:"), 105); pr.step(TTR("Syncing headers"), 0, true); print_verbose("EFS: Connecting taken!"); char header[4]; Error err = tcp_peer->get_data((uint8_t *)&header, 4); ERR_FAIL_COND(err != OK); ERR_FAIL_COND(header[0] != 'G'); ERR_FAIL_COND(header[1] != 'R'); ERR_FAIL_COND(header[2] != 'F'); ERR_FAIL_COND(header[3] != 'S'); uint32_t protocol_version = tcp_peer->get_u32(); ERR_FAIL_COND(protocol_version != FILESYSTEM_PROTOCOL_VERSION); char cpassword[PASSWORD_LENGTH + 1]; err = tcp_peer->get_data((uint8_t *)cpassword, PASSWORD_LENGTH); cpassword[PASSWORD_LENGTH] = 0; ERR_FAIL_COND(err != OK); print_verbose("EFS: Got password: " + String(cpassword)); ERR_FAIL_COND_MSG(password != cpassword, "Client disconnected because password mismatch."); uint32_t tag_count = tcp_peer->get_u32(); print_verbose("EFS: Getting tags: " + itos(tag_count)); ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED); Vector<String> tags; for (uint32_t i = 0; i < tag_count; i++) { String tag = tcp_peer->get_utf8_string(); print_verbose("EFS: tag #" + itos(i) + ": " + tag); ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED); tags.push_back(tag); } uint32_t file_buffer_decompressed_size = tcp_peer->get_32(); HashMap<String, uint64_t> cached_files; if (file_buffer_decompressed_size > 0) { pr.step(TTR("Getting remote file system"), 1, true); // Got files cached by client. uint32_t file_buffer_size = tcp_peer->get_32(); print_verbose("EFS: Getting file buffer: compressed - " + String::humanize_size(file_buffer_size) + " decompressed: " + String::humanize_size(file_buffer_decompressed_size)); ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED); ERR_FAIL_COND(file_buffer_size > MAX_FILE_BUFFER_SIZE); LocalVector<uint8_t> file_buffer; file_buffer.resize(file_buffer_size); LocalVector<uint8_t> file_buffer_decompressed; file_buffer_decompressed.resize(file_buffer_decompressed_size); err = tcp_peer->get_data(file_buffer.ptr(), file_buffer_size); pr.step(TTR("Decompressing remote file system"), 2, true); ERR_FAIL_COND(err != OK); // Decompress the text with all the files Compression::decompress(file_buffer_decompressed.ptr(), file_buffer_decompressed.size(), file_buffer.ptr(), file_buffer.size(), Compression::MODE_ZSTD); String files_text = String::utf8((const char *)file_buffer_decompressed.ptr(), file_buffer_decompressed.size()); Vector<String> files = files_text.split("\n"); print_verbose("EFS: Total cached files received: " + itos(files.size())); for (int i = 0; i < files.size(); i++) { if (files[i].get_slice_count("::") != 2) { continue; } String file = files[i].get_slice("::", 0); uint64_t modified_time = files[i].get_slice("::", 1).to_int(); cached_files.insert(file, modified_time); } } else { // Client does not have any files stored. } pr.step(TTR("Scanning for local changes"), 3, true); print_verbose("EFS: Scanning changes:"); HashMap<String, uint64_t> files_to_send; // Scan files to send. _scan_files_changed(EditorFileSystem::get_singleton()->get_filesystem(), tags, files_to_send, cached_files); // Add forced export files Vector<String> forced_export = EditorExportPlatform::get_forced_export_files(); for (int i = 0; i < forced_export.size(); i++) { _add_custom_file(forced_export[i], files_to_send, cached_files); } _add_custom_file("res://project.godot", files_to_send, cached_files); // Check which files were removed and also add them for (KeyValue<String, uint64_t> K : cached_files) { if (!files_to_send.has(K.key)) { files_to_send.insert(K.key, 0); //0 means removed } } tcp_peer->put_32(files_to_send.size()); print_verbose("EFS: Sending list of changed files."); pr.step(TTR("Sending list of changed files:"), 4, true); // Send list of changed files first, to ensure that if connecting breaks, the client is not found in a broken state. for (KeyValue<String, uint64_t> K : files_to_send) { tcp_peer->put_utf8_string(K.key); tcp_peer->put_64(K.value); } print_verbose("EFS: Sending " + itos(files_to_send.size()) + " files."); int idx = 0; for (KeyValue<String, uint64_t> K : files_to_send) { pr.step(TTR("Sending file:") + " " + K.key.get_file(), 5 + idx * 100 / files_to_send.size(), false); idx++; if (K.value == 0 || !FileAccess::exists("res://" + K.key)) { // File was removed continue; } Vector<uint8_t> array = FileAccess::_get_file_as_bytes("res://" + K.key); tcp_peer->put_64(array.size()); tcp_peer->put_data(array.ptr(), array.size()); ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED); } tcp_peer->put_data((const uint8_t *)"GEND", 4); // End marker. print_verbose("EFS: Done."); } void EditorFileServer::start() { if (active) { stop(); } port = EDITOR_GET("filesystem/file_server/port"); password = EDITOR_GET("filesystem/file_server/password"); Error err = server->listen(port); ERR_FAIL_COND_MSG(err != OK, "EditorFileServer: Unable to listen on port " + itos(port)); active = true; } bool EditorFileServer::is_active() const { return active; } void EditorFileServer::stop() { if (active) { server->stop(); active = false; } } EditorFileServer::EditorFileServer() { server.instantiate(); EDITOR_DEF("filesystem/file_server/port", 6010); EDITOR_DEF("filesystem/file_server/password", ""); } EditorFileServer::~EditorFileServer() { stop(); }